// +build !minimal

#define protected public
#define private public

#include "widgets.h"
#include "_cgo_export.h"

#include <QAbstractAnimation>
#include <QAbstractButton>
#include <QAbstractGraphicsShapeItem>
#include <QAbstractItemDelegate>
#include <QAbstractItemModel>
#include <QAbstractItemView>
#include <QAbstractProxyModel>
#include <QAbstractScrollArea>
#include <QAbstractSlider>
#include <QAbstractSpinBox>
#include <QAbstractState>
#include <QAccessible>
#include <QAccessibleInterface>
#include <QAccessibleWidget>
#include <QAction>
#include <QActionEvent>
#include <QActionGroup>
#include <QApplication>
#include <QAudioSystemPlugin>
#include <QBitmap>
#include <QBoxLayout>
#include <QBrush>
#include <QButtonGroup>
#include <QByteArray>
#include <QCalendarWidget>
#include <QCameraImageCapture>
#include <QCheckBox>
#include <QChildEvent>
#include <QCloseEvent>
#include <QColor>
#include <QColorDialog>
#include <QColormap>
#include <QColumnView>
#include <QComboBox>
#include <QCommandLinkButton>
#include <QCommonStyle>
#include <QCompleter>
#include <QContextMenuEvent>
#include <QCursor>
#include <QDBusPendingCallWatcher>
#include <QDataStream>
#include <QDataWidgetMapper>
#include <QDate>
#include <QDateEdit>
#include <QDateTime>
#include <QDateTimeEdit>
#include <QDesktopWidget>
#include <QDial>
#include <QDialog>
#include <QDialogButtonBox>
#include <QDir>
#include <QDirModel>
#include <QDockWidget>
#include <QDoubleSpinBox>
#include <QDragEnterEvent>
#include <QDragLeaveEvent>
#include <QDragMoveEvent>
#include <QDropEvent>
#include <QErrorMessage>
#include <QEvent>
#include <QExtensionFactory>
#include <QExtensionManager>
#include <QFileDialog>
#include <QFileIconProvider>
#include <QFileInfo>
#include <QFileSystemModel>
#include <QFocusEvent>
#include <QFocusFrame>
#include <QFont>
#include <QFontComboBox>
#include <QFontDatabase>
#include <QFontDialog>
#include <QFontInfo>
#include <QFontMetrics>
#include <QFormLayout>
#include <QFrame>
#include <QGesture>
#include <QGestureEvent>
#include <QGestureRecognizer>
#include <QGraphicsAnchor>
#include <QGraphicsAnchorLayout>
#include <QGraphicsBlurEffect>
#include <QGraphicsColorizeEffect>
#include <QGraphicsDropShadowEffect>
#include <QGraphicsEffect>
#include <QGraphicsEllipseItem>
#include <QGraphicsGridLayout>
#include <QGraphicsItem>
#include <QGraphicsItemAnimation>
#include <QGraphicsItemGroup>
#include <QGraphicsLayout>
#include <QGraphicsLayoutItem>
#include <QGraphicsLineItem>
#include <QGraphicsLinearLayout>
#include <QGraphicsObject>
#include <QGraphicsOpacityEffect>
#include <QGraphicsPathItem>
#include <QGraphicsPixmapItem>
#include <QGraphicsPolygonItem>
#include <QGraphicsProxyWidget>
#include <QGraphicsRectItem>
#include <QGraphicsRotation>
#include <QGraphicsScale>
#include <QGraphicsScene>
#include <QGraphicsSceneContextMenuEvent>
#include <QGraphicsSceneDragDropEvent>
#include <QGraphicsSceneEvent>
#include <QGraphicsSceneHelpEvent>
#include <QGraphicsSceneHoverEvent>
#include <QGraphicsSceneMouseEvent>
#include <QGraphicsSceneMoveEvent>
#include <QGraphicsSceneResizeEvent>
#include <QGraphicsSceneWheelEvent>
#include <QGraphicsSimpleTextItem>
#include <QGraphicsTextItem>
#include <QGraphicsTransform>
#include <QGraphicsView>
#include <QGraphicsWidget>
#include <QGridLayout>
#include <QGroupBox>
#include <QHBoxLayout>
#include <QHash>
#include <QHeaderView>
#include <QHelpEvent>
#include <QHideEvent>
#include <QIcon>
#include <QImage>
#include <QInputDialog>
#include <QInputMethodEvent>
#include <QItemDelegate>
#include <QItemEditorCreatorBase>
#include <QItemEditorFactory>
#include <QItemSelection>
#include <QItemSelectionModel>
#include <QKeyEvent>
#include <QKeyEventTransition>
#include <QKeySequence>
#include <QKeySequenceEdit>
#include <QLCDNumber>
#include <QLabel>
#include <QLayout>
#include <QLayoutItem>
#include <QLine>
#include <QLineEdit>
#include <QLineF>
#include <QListView>
#include <QListWidget>
#include <QListWidgetItem>
#include <QLocale>
#include <QMainWindow>
#include <QMap>
#include <QMargins>
#include <QMatrix>
#include <QMatrix4x4>
#include <QMdiArea>
#include <QMdiSubWindow>
#include <QMediaPlaylist>
#include <QMediaRecorder>
#include <QMediaServiceProviderPlugin>
#include <QMenu>
#include <QMenuBar>
#include <QMessageBox>
#include <QMetaMethod>
#include <QMetaObject>
#include <QMimeData>
#include <QModelIndex>
#include <QMouseEvent>
#include <QMouseEventTransition>
#include <QMoveEvent>
#include <QMovie>
#include <QObject>
#include <QOffscreenSurface>
#include <QOpenGLWidget>
#include <QPagedPaintDevice>
#include <QPaintDevice>
#include <QPaintDeviceWindow>
#include <QPaintEngine>
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
#include <QPalette>
#include <QPanGesture>
#include <QPdfWriter>
#include <QPen>
#include <QPersistentModelIndex>
#include <QPicture>
#include <QPinchGesture>
#include <QPixmap>
#include <QPlainTextDocumentLayout>
#include <QPlainTextEdit>
#include <QPoint>
#include <QPointF>
#include <QPolygon>
#include <QPolygonF>
#include <QProgressBar>
#include <QProgressDialog>
#include <QProxyStyle>
#include <QPushButton>
#include <QQuickItem>
#include <QRadioButton>
#include <QRadioData>
#include <QRect>
#include <QRectF>
#include <QRegExp>
#include <QRegion>
#include <QRegularExpression>
#include <QRemoteObjectPendingCallWatcher>
#include <QResizeEvent>
#include <QRubberBand>
#include <QScreen>
#include <QScriptExtensionPlugin>
#include <QScrollArea>
#include <QScrollBar>
#include <QScroller>
#include <QScrollerProperties>
#include <QSessionManager>
#include <QShortcut>
#include <QShowEvent>
#include <QSize>
#include <QSizeF>
#include <QSizeGrip>
#include <QSizePolicy>
#include <QSlider>
#include <QSpacerItem>
#include <QSpinBox>
#include <QSplashScreen>
#include <QSplitter>
#include <QSplitterHandle>
#include <QStackedLayout>
#include <QStackedWidget>
#include <QState>
#include <QStatusBar>
#include <QString>
#include <QStyle>
#include <QStyleFactory>
#include <QStyleHintReturn>
#include <QStyleHintReturnMask>
#include <QStyleHintReturnVariant>
#include <QStyleOption>
#include <QStyleOptionButton>
#include <QStyleOptionComboBox>
#include <QStyleOptionComplex>
#include <QStyleOptionDockWidget>
#include <QStyleOptionFocusRect>
#include <QStyleOptionFrame>
#include <QStyleOptionGraphicsItem>
#include <QStyleOptionGroupBox>
#include <QStyleOptionHeader>
#include <QStyleOptionMenuItem>
#include <QStyleOptionProgressBar>
#include <QStyleOptionRubberBand>
#include <QStyleOptionSizeGrip>
#include <QStyleOptionSlider>
#include <QStyleOptionSpinBox>
#include <QStyleOptionTab>
#include <QStyleOptionTabBarBase>
#include <QStyleOptionTabWidgetFrame>
#include <QStyleOptionTitleBar>
#include <QStyleOptionToolBar>
#include <QStyleOptionToolBox>
#include <QStyleOptionToolButton>
#include <QStyleOptionViewItem>
#include <QStylePainter>
#include <QStylePlugin>
#include <QStyledItemDelegate>
#include <QSurfaceFormat>
#include <QSwipeGesture>
#include <QSystemTrayIcon>
#include <QTabBar>
#include <QTabWidget>
#include <QTableView>
#include <QTableWidget>
#include <QTableWidgetItem>
#include <QTableWidgetSelectionRange>
#include <QTabletEvent>
#include <QTapAndHoldGesture>
#include <QTapGesture>
#include <QTextBlock>
#include <QTextBrowser>
#include <QTextCharFormat>
#include <QTextCursor>
#include <QTextDocument>
#include <QTextEdit>
#include <QTextFormat>
#include <QTextFrame>
#include <QTextInlineObject>
#include <QTextOption>
#include <QTileRules>
#include <QTime>
#include <QTimeEdit>
#include <QTimeLine>
#include <QTimerEvent>
#include <QToolBar>
#include <QToolBox>
#include <QToolButton>
#include <QToolTip>
#include <QTransform>
#include <QTreeView>
#include <QTreeWidget>
#include <QTreeWidgetItem>
#include <QUndoCommand>
#include <QUndoGroup>
#include <QUndoStack>
#include <QUndoView>
#include <QUrl>
#include <QVBoxLayout>
#include <QValidator>
#include <QVariant>
#include <QVector>
#include <QVector3D>
#include <QWhatsThis>
#include <QWheelEvent>
#include <QWidget>
#include <QWidgetAction>
#include <QWidgetItem>
#include <QWindow>
#include <QWizard>
#include <QWizardPage>

class MyQAbstractButton: public QAbstractButton
{
public:
	MyQAbstractButton(QWidget *parent = Q_NULLPTR) : QAbstractButton(parent) {QAbstractButton_QAbstractButton_QRegisterMetaType();};
	void animateClick(int msec) { callbackQAbstractButton_AnimateClick(this, msec); };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void checkStateSet() { callbackQAbstractButton_CheckStateSet(this); };
	void click() { callbackQAbstractButton_Click(this); };
	void Signal_Clicked(bool checked) { callbackQAbstractButton_Clicked(this, checked); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void focusInEvent(QFocusEvent * e) { callbackQWidget_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQWidget_FocusOutEvent(this, e); };
	bool hitButton(const QPoint & pos) const { return callbackQAbstractButton_HitButton(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&pos)) != 0; };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQWidget_KeyReleaseEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void nextCheckState() { callbackQAbstractButton_NextCheckState(this); };
	void paintEvent(QPaintEvent * e) { callbackQAbstractButton_PaintEvent(this, e); };
	void Signal_Pressed() { callbackQAbstractButton_Pressed(this); };
	void Signal_Released() { callbackQAbstractButton_Released(this); };
	void setChecked(bool vbo) { callbackQAbstractButton_SetChecked(this, vbo); };
	void setIconSize(const QSize & size) { callbackQAbstractButton_SetIconSize(this, const_cast<QSize*>(&size)); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void toggle() { callbackQAbstractButton_Toggle(this); };
	void Signal_Toggled(bool checked) { callbackQAbstractButton_Toggled(this, checked); };
	 ~MyQAbstractButton() { callbackQAbstractButton_DestroyQAbstractButton(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QAbstractButton*)
Q_DECLARE_METATYPE(MyQAbstractButton*)

int QAbstractButton_QAbstractButton_QRegisterMetaType(){qRegisterMetaType<QAbstractButton*>(); return qRegisterMetaType<MyQAbstractButton*>();}

void* QAbstractButton_NewQAbstractButton(void* parent)
{
		return new MyQAbstractButton(static_cast<QWidget*>(parent));
}

void QAbstractButton_AnimateClick(void* ptr, int msec)
{
	QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "animateClick", Q_ARG(int, msec));
}

void QAbstractButton_AnimateClickDefault(void* ptr, int msec)
{
	if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::animateClick(msec);
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::animateClick(msec);
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::animateClick(msec);
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::animateClick(msec);
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::animateClick(msec);
	} else {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::animateClick(msec);
	}
}

char QAbstractButton_AutoExclusive(void* ptr)
{
	return static_cast<QAbstractButton*>(ptr)->autoExclusive();
}

char QAbstractButton_AutoRepeat(void* ptr)
{
	return static_cast<QAbstractButton*>(ptr)->autoRepeat();
}

int QAbstractButton_AutoRepeatDelay(void* ptr)
{
	return static_cast<QAbstractButton*>(ptr)->autoRepeatDelay();
}

int QAbstractButton_AutoRepeatInterval(void* ptr)
{
	return static_cast<QAbstractButton*>(ptr)->autoRepeatInterval();
}

void QAbstractButton_CheckStateSet(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->checkStateSet();
}

void QAbstractButton_CheckStateSetDefault(void* ptr)
{
	if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::checkStateSet();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::checkStateSet();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::checkStateSet();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::checkStateSet();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::checkStateSet();
	} else {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::checkStateSet();
	}
}

void QAbstractButton_Click(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "click");
}

void QAbstractButton_ClickDefault(void* ptr)
{
	if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::click();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::click();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::click();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::click();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::click();
	} else {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::click();
	}
}

void QAbstractButton_ConnectClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractButton*>(ptr), static_cast<void (QAbstractButton::*)(bool)>(&QAbstractButton::clicked), static_cast<MyQAbstractButton*>(ptr), static_cast<void (MyQAbstractButton::*)(bool)>(&MyQAbstractButton::Signal_Clicked), static_cast<Qt::ConnectionType>(t));
}

void QAbstractButton_DisconnectClicked(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractButton*>(ptr), static_cast<void (QAbstractButton::*)(bool)>(&QAbstractButton::clicked), static_cast<MyQAbstractButton*>(ptr), static_cast<void (MyQAbstractButton::*)(bool)>(&MyQAbstractButton::Signal_Clicked));
}

void QAbstractButton_Clicked(void* ptr, char checked)
{
	static_cast<QAbstractButton*>(ptr)->clicked(checked != 0);
}

void* QAbstractButton_Group(void* ptr)
{
	return static_cast<QAbstractButton*>(ptr)->group();
}

char QAbstractButton_HitButton(void* ptr, void* pos)
{
	return static_cast<QAbstractButton*>(ptr)->hitButton(*static_cast<QPoint*>(pos));
}

char QAbstractButton_HitButtonDefault(void* ptr, void* pos)
{
	if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolButton*>(ptr)->QToolButton::hitButton(*static_cast<QPoint*>(pos));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioButton*>(ptr)->QRadioButton::hitButton(*static_cast<QPoint*>(pos));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::hitButton(*static_cast<QPoint*>(pos));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPushButton*>(ptr)->QPushButton::hitButton(*static_cast<QPoint*>(pos));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCheckBox*>(ptr)->QCheckBox::hitButton(*static_cast<QPoint*>(pos));
	} else {
		return static_cast<QAbstractButton*>(ptr)->QAbstractButton::hitButton(*static_cast<QPoint*>(pos));
	}
}

void* QAbstractButton_Icon(void* ptr)
{
	return new QIcon(static_cast<QAbstractButton*>(ptr)->icon());
}

void* QAbstractButton_IconSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QAbstractButton*>(ptr)->iconSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

char QAbstractButton_IsCheckable(void* ptr)
{
	return static_cast<QAbstractButton*>(ptr)->isCheckable();
}

char QAbstractButton_IsChecked(void* ptr)
{
	return static_cast<QAbstractButton*>(ptr)->isChecked();
}

char QAbstractButton_IsDown(void* ptr)
{
	return static_cast<QAbstractButton*>(ptr)->isDown();
}

void QAbstractButton_NextCheckState(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->nextCheckState();
}

void QAbstractButton_NextCheckStateDefault(void* ptr)
{
	if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::nextCheckState();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::nextCheckState();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::nextCheckState();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::nextCheckState();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::nextCheckState();
	} else {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::nextCheckState();
	}
}

void QAbstractButton_PaintEvent(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->paintEvent(static_cast<QPaintEvent*>(e));
}

void QAbstractButton_ConnectPressed(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractButton*>(ptr), static_cast<void (QAbstractButton::*)()>(&QAbstractButton::pressed), static_cast<MyQAbstractButton*>(ptr), static_cast<void (MyQAbstractButton::*)()>(&MyQAbstractButton::Signal_Pressed), static_cast<Qt::ConnectionType>(t));
}

void QAbstractButton_DisconnectPressed(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractButton*>(ptr), static_cast<void (QAbstractButton::*)()>(&QAbstractButton::pressed), static_cast<MyQAbstractButton*>(ptr), static_cast<void (MyQAbstractButton::*)()>(&MyQAbstractButton::Signal_Pressed));
}

void QAbstractButton_Pressed(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->pressed();
}

void QAbstractButton_ConnectReleased(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractButton*>(ptr), static_cast<void (QAbstractButton::*)()>(&QAbstractButton::released), static_cast<MyQAbstractButton*>(ptr), static_cast<void (MyQAbstractButton::*)()>(&MyQAbstractButton::Signal_Released), static_cast<Qt::ConnectionType>(t));
}

void QAbstractButton_DisconnectReleased(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractButton*>(ptr), static_cast<void (QAbstractButton::*)()>(&QAbstractButton::released), static_cast<MyQAbstractButton*>(ptr), static_cast<void (MyQAbstractButton::*)()>(&MyQAbstractButton::Signal_Released));
}

void QAbstractButton_Released(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->released();
}

void QAbstractButton_SetAutoExclusive(void* ptr, char vbo)
{
	static_cast<QAbstractButton*>(ptr)->setAutoExclusive(vbo != 0);
}

void QAbstractButton_SetAutoRepeat(void* ptr, char vbo)
{
	static_cast<QAbstractButton*>(ptr)->setAutoRepeat(vbo != 0);
}

void QAbstractButton_SetAutoRepeatDelay(void* ptr, int vin)
{
	static_cast<QAbstractButton*>(ptr)->setAutoRepeatDelay(vin);
}

void QAbstractButton_SetAutoRepeatInterval(void* ptr, int vin)
{
	static_cast<QAbstractButton*>(ptr)->setAutoRepeatInterval(vin);
}

void QAbstractButton_SetCheckable(void* ptr, char vbo)
{
	static_cast<QAbstractButton*>(ptr)->setCheckable(vbo != 0);
}

void QAbstractButton_SetChecked(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}

void QAbstractButton_SetCheckedDefault(void* ptr, char vbo)
{
	if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::setChecked(vbo != 0);
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::setChecked(vbo != 0);
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setChecked(vbo != 0);
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::setChecked(vbo != 0);
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::setChecked(vbo != 0);
	} else {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::setChecked(vbo != 0);
	}
}

void QAbstractButton_SetDown(void* ptr, char vbo)
{
	static_cast<QAbstractButton*>(ptr)->setDown(vbo != 0);
}

void QAbstractButton_SetIcon(void* ptr, void* icon)
{
	static_cast<QAbstractButton*>(ptr)->setIcon(*static_cast<QIcon*>(icon));
}

void QAbstractButton_SetIconSize(void* ptr, void* size)
{
	QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "setIconSize", Q_ARG(const QSize, *static_cast<QSize*>(size)));
}

void QAbstractButton_SetIconSizeDefault(void* ptr, void* size)
{
	if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::setIconSize(*static_cast<QSize*>(size));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::setIconSize(*static_cast<QSize*>(size));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setIconSize(*static_cast<QSize*>(size));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::setIconSize(*static_cast<QSize*>(size));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::setIconSize(*static_cast<QSize*>(size));
	} else {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::setIconSize(*static_cast<QSize*>(size));
	}
}

void QAbstractButton_SetShortcut(void* ptr, void* key)
{
	static_cast<QAbstractButton*>(ptr)->setShortcut(*static_cast<QKeySequence*>(key));
}

void QAbstractButton_SetText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QAbstractButton*>(ptr)->setText(QString::fromUtf8(text.data, text.len));
}

void* QAbstractButton_Shortcut(void* ptr)
{
	return new QKeySequence(static_cast<QAbstractButton*>(ptr)->shortcut());
}

struct QtWidgets_PackedString QAbstractButton_Text(void* ptr)
{
	return ({ QByteArray* t8ae7db = new QByteArray(static_cast<QAbstractButton*>(ptr)->text().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t8ae7db->prepend("WHITESPACE").constData()+10), t8ae7db->size()-10, t8ae7db }; });
}

void QAbstractButton_Toggle(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "toggle");
}

void QAbstractButton_ToggleDefault(void* ptr)
{
	if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::toggle();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::toggle();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::toggle();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::toggle();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::toggle();
	} else {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::toggle();
	}
}

void QAbstractButton_ConnectToggled(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractButton*>(ptr), static_cast<void (QAbstractButton::*)(bool)>(&QAbstractButton::toggled), static_cast<MyQAbstractButton*>(ptr), static_cast<void (MyQAbstractButton::*)(bool)>(&MyQAbstractButton::Signal_Toggled), static_cast<Qt::ConnectionType>(t));
}

void QAbstractButton_DisconnectToggled(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractButton*>(ptr), static_cast<void (QAbstractButton::*)(bool)>(&QAbstractButton::toggled), static_cast<MyQAbstractButton*>(ptr), static_cast<void (MyQAbstractButton::*)(bool)>(&MyQAbstractButton::Signal_Toggled));
}

void QAbstractButton_Toggled(void* ptr, char checked)
{
	static_cast<QAbstractButton*>(ptr)->toggled(checked != 0);
}

void QAbstractButton_DestroyQAbstractButton(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->~QAbstractButton();
}

void QAbstractButton_DestroyQAbstractButtonDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQAbstractGraphicsShapeItem: public QAbstractGraphicsShapeItem
{
public:
	MyQAbstractGraphicsShapeItem(QGraphicsItem *parent = Q_NULLPTR) : QAbstractGraphicsShapeItem(parent) {QAbstractGraphicsShapeItem_QAbstractGraphicsShapeItem_QRegisterMetaType();};
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQAbstractGraphicsShapeItem() { callbackQAbstractGraphicsShapeItem_DestroyQAbstractGraphicsShapeItem(this); };
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQAbstractGraphicsShapeItem_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQAbstractGraphicsShapeItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
};

Q_DECLARE_METATYPE(QAbstractGraphicsShapeItem*)
Q_DECLARE_METATYPE(MyQAbstractGraphicsShapeItem*)

int QAbstractGraphicsShapeItem_QAbstractGraphicsShapeItem_QRegisterMetaType(){qRegisterMetaType<QAbstractGraphicsShapeItem*>(); return qRegisterMetaType<MyQAbstractGraphicsShapeItem*>();}

void* QAbstractGraphicsShapeItem_NewQAbstractGraphicsShapeItem(void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractGraphicsShapeItem(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractGraphicsShapeItem(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQAbstractGraphicsShapeItem(static_cast<QGraphicsItem*>(parent));
	}
}

void* QAbstractGraphicsShapeItem_Brush(void* ptr)
{
	return new QBrush(static_cast<QAbstractGraphicsShapeItem*>(ptr)->brush());
}

void* QAbstractGraphicsShapeItem_Pen(void* ptr)
{
	return new QPen(static_cast<QAbstractGraphicsShapeItem*>(ptr)->pen());
}

void QAbstractGraphicsShapeItem_SetBrush(void* ptr, void* brush)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->setBrush(*static_cast<QBrush*>(brush));
}

void QAbstractGraphicsShapeItem_SetPen(void* ptr, void* pen)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->setPen(*static_cast<QPen*>(pen));
}

void QAbstractGraphicsShapeItem_DestroyQAbstractGraphicsShapeItem(void* ptr)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->~QAbstractGraphicsShapeItem();
}

void QAbstractGraphicsShapeItem_DestroyQAbstractGraphicsShapeItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QAbstractGraphicsShapeItem_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QAbstractGraphicsShapeItem*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QAbstractGraphicsShapeItem_BoundingRectDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QAbstractGraphicsShapeItem*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QAbstractGraphicsShapeItem*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QAbstractGraphicsShapeItem*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QAbstractGraphicsShapeItem*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QAbstractGraphicsShapeItem*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
	
	}
}

void QAbstractGraphicsShapeItem_Paint(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QAbstractGraphicsShapeItem_PaintDefault(void* ptr, void* painter, void* option, void* widget)
{
	if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QAbstractGraphicsShapeItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QAbstractGraphicsShapeItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QAbstractGraphicsShapeItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QAbstractGraphicsShapeItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QAbstractGraphicsShapeItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	} else {
	
	}
}

class MyQAbstractItemDelegate: public QAbstractItemDelegate
{
public:
	MyQAbstractItemDelegate(QObject *parent = Q_NULLPTR) : QAbstractItemDelegate(parent) {QAbstractItemDelegate_QAbstractItemDelegate_QRegisterMetaType();};
	void Signal_CloseEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemDelegate_CloseEditor(this, editor, hint); };
	void Signal_CommitData(QWidget * editor) { callbackQAbstractItemDelegate_CommitData(this, editor); };
	QWidget * createEditor(QWidget * parent, const QStyleOptionViewItem & option, const QModelIndex & index) const { return static_cast<QWidget*>(callbackQAbstractItemDelegate_CreateEditor(const_cast<void*>(static_cast<const void*>(this)), parent, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index))); };
	void destroyEditor(QWidget * editor, const QModelIndex & index) const { callbackQAbstractItemDelegate_DestroyEditor(const_cast<void*>(static_cast<const void*>(this)), editor, const_cast<QModelIndex*>(&index)); };
	bool editorEvent(QEvent * event, QAbstractItemModel * model, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQAbstractItemDelegate_EditorEvent(this, event, model, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)) != 0; };
	bool helpEvent(QHelpEvent * event, QAbstractItemView * view, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQAbstractItemDelegate_HelpEvent(this, event, view, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)) != 0; };
	void paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQAbstractItemDelegate_Paint(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	void setEditorData(QWidget * editor, const QModelIndex & index) const { callbackQAbstractItemDelegate_SetEditorData(const_cast<void*>(static_cast<const void*>(this)), editor, const_cast<QModelIndex*>(&index)); };
	void setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex & index) const { callbackQAbstractItemDelegate_SetModelData(const_cast<void*>(static_cast<const void*>(this)), editor, model, const_cast<QModelIndex*>(&index)); };
	QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex & index) const { return *static_cast<QSize*>(callbackQAbstractItemDelegate_SizeHint(const_cast<void*>(static_cast<const void*>(this)), const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index))); };
	void Signal_SizeHintChanged(const QModelIndex & index) { callbackQAbstractItemDelegate_SizeHintChanged(this, const_cast<QModelIndex*>(&index)); };
	void updateEditorGeometry(QWidget * editor, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQAbstractItemDelegate_UpdateEditorGeometry(const_cast<void*>(static_cast<const void*>(this)), editor, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	 ~MyQAbstractItemDelegate() { callbackQAbstractItemDelegate_DestroyQAbstractItemDelegate(this); };
	void childEvent(QChildEvent * event) { callbackQAbstractItemDelegate_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractItemDelegate_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractItemDelegate_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractItemDelegate_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAbstractItemDelegate_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractItemDelegate_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQAbstractItemDelegate_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractItemDelegate_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractItemDelegate_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAbstractItemDelegate_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAbstractItemDelegate_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAbstractItemDelegate*)
Q_DECLARE_METATYPE(MyQAbstractItemDelegate*)

int QAbstractItemDelegate_QAbstractItemDelegate_QRegisterMetaType(){qRegisterMetaType<QAbstractItemDelegate*>(); return qRegisterMetaType<MyQAbstractItemDelegate*>();}

void* QAbstractItemDelegate_NewQAbstractItemDelegate(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAbstractItemDelegate(static_cast<QWindow*>(parent));
	} else {
		return new MyQAbstractItemDelegate(static_cast<QObject*>(parent));
	}
}

void QAbstractItemDelegate_ConnectCloseEditor(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractItemDelegate*>(ptr), static_cast<void (QAbstractItemDelegate::*)(QWidget *, QAbstractItemDelegate::EndEditHint)>(&QAbstractItemDelegate::closeEditor), static_cast<MyQAbstractItemDelegate*>(ptr), static_cast<void (MyQAbstractItemDelegate::*)(QWidget *, QAbstractItemDelegate::EndEditHint)>(&MyQAbstractItemDelegate::Signal_CloseEditor), static_cast<Qt::ConnectionType>(t));
}

void QAbstractItemDelegate_DisconnectCloseEditor(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractItemDelegate*>(ptr), static_cast<void (QAbstractItemDelegate::*)(QWidget *, QAbstractItemDelegate::EndEditHint)>(&QAbstractItemDelegate::closeEditor), static_cast<MyQAbstractItemDelegate*>(ptr), static_cast<void (MyQAbstractItemDelegate::*)(QWidget *, QAbstractItemDelegate::EndEditHint)>(&MyQAbstractItemDelegate::Signal_CloseEditor));
}

void QAbstractItemDelegate_CloseEditor(void* ptr, void* editor, long long hint)
{
		static_cast<QAbstractItemDelegate*>(ptr)->closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
}

void QAbstractItemDelegate_ConnectCommitData(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractItemDelegate*>(ptr), static_cast<void (QAbstractItemDelegate::*)(QWidget *)>(&QAbstractItemDelegate::commitData), static_cast<MyQAbstractItemDelegate*>(ptr), static_cast<void (MyQAbstractItemDelegate::*)(QWidget *)>(&MyQAbstractItemDelegate::Signal_CommitData), static_cast<Qt::ConnectionType>(t));
}

void QAbstractItemDelegate_DisconnectCommitData(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractItemDelegate*>(ptr), static_cast<void (QAbstractItemDelegate::*)(QWidget *)>(&QAbstractItemDelegate::commitData), static_cast<MyQAbstractItemDelegate*>(ptr), static_cast<void (MyQAbstractItemDelegate::*)(QWidget *)>(&MyQAbstractItemDelegate::Signal_CommitData));
}

void QAbstractItemDelegate_CommitData(void* ptr, void* editor)
{
		static_cast<QAbstractItemDelegate*>(ptr)->commitData(static_cast<QWidget*>(editor));
}

void* QAbstractItemDelegate_CreateEditor(void* ptr, void* parent, void* option, void* index)
{
		return static_cast<QAbstractItemDelegate*>(ptr)->createEditor(static_cast<QWidget*>(parent), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void* QAbstractItemDelegate_CreateEditorDefault(void* ptr, void* parent, void* option, void* index)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::createEditor(static_cast<QWidget*>(parent), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		return static_cast<QItemDelegate*>(ptr)->QItemDelegate::createEditor(static_cast<QWidget*>(parent), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	} else {
		return static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::createEditor(static_cast<QWidget*>(parent), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	}
}

void QAbstractItemDelegate_DestroyEditor(void* ptr, void* editor, void* index)
{
		static_cast<QAbstractItemDelegate*>(ptr)->destroyEditor(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
}

void QAbstractItemDelegate_DestroyEditorDefault(void* ptr, void* editor, void* index)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::destroyEditor(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::destroyEditor(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
	} else {
		static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::destroyEditor(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
	}
}

char QAbstractItemDelegate_EditorEvent(void* ptr, void* event, void* model, void* option, void* index)
{
	return static_cast<QAbstractItemDelegate*>(ptr)->editorEvent(static_cast<QEvent*>(event), static_cast<QAbstractItemModel*>(model), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

char QAbstractItemDelegate_EditorEventDefault(void* ptr, void* event, void* model, void* option, void* index)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::editorEvent(static_cast<QEvent*>(event), static_cast<QAbstractItemModel*>(model), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		return static_cast<QItemDelegate*>(ptr)->QItemDelegate::editorEvent(static_cast<QEvent*>(event), static_cast<QAbstractItemModel*>(model), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	} else {
		return static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::editorEvent(static_cast<QEvent*>(event), static_cast<QAbstractItemModel*>(model), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	}
}

char QAbstractItemDelegate_HelpEvent(void* ptr, void* event, void* view, void* option, void* index)
{
	return static_cast<QAbstractItemDelegate*>(ptr)->helpEvent(static_cast<QHelpEvent*>(event), static_cast<QAbstractItemView*>(view), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

char QAbstractItemDelegate_HelpEventDefault(void* ptr, void* event, void* view, void* option, void* index)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::helpEvent(static_cast<QHelpEvent*>(event), static_cast<QAbstractItemView*>(view), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		return static_cast<QItemDelegate*>(ptr)->QItemDelegate::helpEvent(static_cast<QHelpEvent*>(event), static_cast<QAbstractItemView*>(view), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	} else {
		return static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::helpEvent(static_cast<QHelpEvent*>(event), static_cast<QAbstractItemView*>(view), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	}
}

void QAbstractItemDelegate_Paint(void* ptr, void* painter, void* option, void* index)
{
	static_cast<QAbstractItemDelegate*>(ptr)->paint(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QAbstractItemDelegate_SetEditorData(void* ptr, void* editor, void* index)
{
		static_cast<QAbstractItemDelegate*>(ptr)->setEditorData(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
}

void QAbstractItemDelegate_SetEditorDataDefault(void* ptr, void* editor, void* index)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::setEditorData(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::setEditorData(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
	} else {
		static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::setEditorData(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
	}
}

void QAbstractItemDelegate_SetModelData(void* ptr, void* editor, void* model, void* index)
{
		static_cast<QAbstractItemDelegate*>(ptr)->setModelData(static_cast<QWidget*>(editor), static_cast<QAbstractItemModel*>(model), *static_cast<QModelIndex*>(index));
}

void QAbstractItemDelegate_SetModelDataDefault(void* ptr, void* editor, void* model, void* index)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::setModelData(static_cast<QWidget*>(editor), static_cast<QAbstractItemModel*>(model), *static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::setModelData(static_cast<QWidget*>(editor), static_cast<QAbstractItemModel*>(model), *static_cast<QModelIndex*>(index));
	} else {
		static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::setModelData(static_cast<QWidget*>(editor), static_cast<QAbstractItemModel*>(model), *static_cast<QModelIndex*>(index));
	}
}

void* QAbstractItemDelegate_SizeHint(void* ptr, void* option, void* index)
{
	return ({ QSize tmpValue = static_cast<QAbstractItemDelegate*>(ptr)->sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QAbstractItemDelegate_ConnectSizeHintChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractItemDelegate*>(ptr), static_cast<void (QAbstractItemDelegate::*)(const QModelIndex &)>(&QAbstractItemDelegate::sizeHintChanged), static_cast<MyQAbstractItemDelegate*>(ptr), static_cast<void (MyQAbstractItemDelegate::*)(const QModelIndex &)>(&MyQAbstractItemDelegate::Signal_SizeHintChanged), static_cast<Qt::ConnectionType>(t));
}

void QAbstractItemDelegate_DisconnectSizeHintChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractItemDelegate*>(ptr), static_cast<void (QAbstractItemDelegate::*)(const QModelIndex &)>(&QAbstractItemDelegate::sizeHintChanged), static_cast<MyQAbstractItemDelegate*>(ptr), static_cast<void (MyQAbstractItemDelegate::*)(const QModelIndex &)>(&MyQAbstractItemDelegate::Signal_SizeHintChanged));
}

void QAbstractItemDelegate_SizeHintChanged(void* ptr, void* index)
{
	static_cast<QAbstractItemDelegate*>(ptr)->sizeHintChanged(*static_cast<QModelIndex*>(index));
}

void QAbstractItemDelegate_UpdateEditorGeometry(void* ptr, void* editor, void* option, void* index)
{
		static_cast<QAbstractItemDelegate*>(ptr)->updateEditorGeometry(static_cast<QWidget*>(editor), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QAbstractItemDelegate_UpdateEditorGeometryDefault(void* ptr, void* editor, void* option, void* index)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::updateEditorGeometry(static_cast<QWidget*>(editor), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::updateEditorGeometry(static_cast<QWidget*>(editor), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	} else {
		static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::updateEditorGeometry(static_cast<QWidget*>(editor), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	}
}

void QAbstractItemDelegate_DestroyQAbstractItemDelegate(void* ptr)
{
	static_cast<QAbstractItemDelegate*>(ptr)->~QAbstractItemDelegate();
}

void QAbstractItemDelegate_DestroyQAbstractItemDelegateDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

int QAbstractItemDelegate___paintingRoles_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QVector<int>*>(ptr)->at(i); if (i == static_cast<QVector<int>*>(ptr)->size()-1) { static_cast<QVector<int>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}

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

void* QAbstractItemDelegate___paintingRoles_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<int>();
}

void* QAbstractItemDelegate___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractItemDelegate___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QAbstractItemDelegate___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QAbstractItemDelegate___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractItemDelegate___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QAbstractItemDelegate___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAbstractItemDelegate___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void QAbstractItemDelegate_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QAbstractItemDelegate_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QAbstractItemDelegate_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::customEvent(static_cast<QEvent*>(event));
	}
}

void QAbstractItemDelegate_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::deleteLater();
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::deleteLater();
	} else {
		static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::deleteLater();
	}
}

void QAbstractItemDelegate_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

char QAbstractItemDelegate_EventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		return static_cast<QItemDelegate*>(ptr)->QItemDelegate::event(static_cast<QEvent*>(e));
	} else {
		return static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::event(static_cast<QEvent*>(e));
	}
}

char QAbstractItemDelegate_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QItemDelegate*>(ptr)->QItemDelegate::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QItemDelegate*>(ptr)->QItemDelegate::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QItemDelegate*>(ptr)->QItemDelegate::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QItemDelegate*>(ptr)->QItemDelegate::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QItemDelegate*>(ptr)->QItemDelegate::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void* QAbstractItemDelegate_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::metaObject());
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QItemDelegate*>(ptr)->QItemDelegate::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::metaObject());
	}
}

void QAbstractItemDelegate_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QStyledItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QItemDelegate*>(static_cast<QObject*>(ptr))) {
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

class MyQAbstractItemView: public QAbstractItemView
{
public:
	MyQAbstractItemView(QWidget *parent = Q_NULLPTR) : QAbstractItemView(parent) {QAbstractItemView_QAbstractItemView_QRegisterMetaType();};
	void Signal_Activated(const QModelIndex & index) { callbackQAbstractItemView_Activated(this, const_cast<QModelIndex*>(&index)); };
	void clearSelection() { callbackQAbstractItemView_ClearSelection(this); };
	void Signal_Clicked(const QModelIndex & index) { callbackQAbstractItemView_Clicked(this, const_cast<QModelIndex*>(&index)); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQAbstractItemView_CommitData(this, editor); };
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQAbstractItemView_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	void dataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemView_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
	void Signal_DoubleClicked(const QModelIndex & index) { callbackQAbstractItemView_DoubleClicked(this, const_cast<QModelIndex*>(&index)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQAbstractItemView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQAbstractItemView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQAbstractItemView_EditorDestroyed(this, editor); };
	void Signal_Entered(const QModelIndex & index) { callbackQAbstractItemView_Entered(this, const_cast<QModelIndex*>(&index)); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQWidget_EventFilter(this, object, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	int horizontalOffset() const { return callbackQAbstractItemView_HorizontalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_IconSizeChanged(const QSize & size) { callbackQAbstractItemView_IconSizeChanged(this, const_cast<QSize*>(&size)); };
	QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQAbstractItemView_IndexAt(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&point))); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQAbstractItemView_IsIndexHidden(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index)) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { QByteArray* t3559d7 = new QByteArray(search.toUtf8()); QtWidgets_PackedString searchPacked = { const_cast<char*>(t3559d7->prepend("WHITESPACE").constData()+10), t3559d7->size()-10, t3559d7 };callbackQAbstractItemView_KeyboardSearch(this, searchPacked); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQAbstractItemView_MoveCursor(this, cursorAction, modifiers)); };
	void Signal_Pressed(const QModelIndex & index) { callbackQAbstractItemView_Pressed(this, const_cast<QModelIndex*>(&index)); };
	void reset() { callbackQAbstractItemView_Reset(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQAbstractItemView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemView_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQAbstractItemView_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	void scrollToBottom() { callbackQAbstractItemView_ScrollToBottom(this); };
	void scrollToTop() { callbackQAbstractItemView_ScrollToTop(this); };
	void selectAll() { callbackQAbstractItemView_SelectAll(this); };
	QList<QModelIndex> selectedIndexes() const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemView_SelectedIndexes(const_cast<void*>(static_cast<const void*>(this)))); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQAbstractItemView_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQAbstractItemView_SelectionCommand(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQAbstractItemView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	void setModel(QAbstractItemModel * model) { callbackQAbstractItemView_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQAbstractItemView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags flags) { callbackQAbstractItemView_SetSelection(this, const_cast<QRect*>(&rect), flags); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQAbstractItemView_SetSelectionModel(this, selectionModel); };
	int sizeHintForColumn(int column) const { return callbackQAbstractItemView_SizeHintForColumn(const_cast<void*>(static_cast<const void*>(this)), column); };
	int sizeHintForRow(int row) const { return callbackQAbstractItemView_SizeHintForRow(const_cast<void*>(static_cast<const void*>(this)), row); };
	void startDrag(Qt::DropActions supportedActions) { callbackQAbstractItemView_StartDrag(this, supportedActions); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	void update(const QModelIndex & index) { callbackQAbstractItemView_Update(this, const_cast<QModelIndex*>(&index)); };
	void updateGeometries() { callbackQAbstractItemView_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQAbstractItemView_VerticalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQAbstractItemView_ViewOptions(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ViewportEntered() { callbackQAbstractItemView_ViewportEntered(this); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQAbstractItemView_VisualRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQAbstractItemView_VisualRegionForSelection(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&selection))); };
	 ~MyQAbstractItemView() { callbackQAbstractItemView_DestroyQAbstractItemView(this); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QAbstractItemView*)
Q_DECLARE_METATYPE(MyQAbstractItemView*)

int QAbstractItemView_QAbstractItemView_QRegisterMetaType(){qRegisterMetaType<QAbstractItemView*>(); return qRegisterMetaType<MyQAbstractItemView*>();}

void* QAbstractItemView_NewQAbstractItemView(void* parent)
{
		return new MyQAbstractItemView(static_cast<QWidget*>(parent));
}

void QAbstractItemView_ConnectActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)(const QModelIndex &)>(&QAbstractItemView::activated), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)(const QModelIndex &)>(&MyQAbstractItemView::Signal_Activated), static_cast<Qt::ConnectionType>(t));
}

void QAbstractItemView_DisconnectActivated(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)(const QModelIndex &)>(&QAbstractItemView::activated), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)(const QModelIndex &)>(&MyQAbstractItemView::Signal_Activated));
}

void QAbstractItemView_Activated(void* ptr, void* index)
{
	static_cast<QAbstractItemView*>(ptr)->activated(*static_cast<QModelIndex*>(index));
}

char QAbstractItemView_AlternatingRowColors(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->alternatingRowColors();
}

int QAbstractItemView_AutoScrollMargin(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->autoScrollMargin();
}

void QAbstractItemView_ClearSelection(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "clearSelection");
}

void QAbstractItemView_ClearSelectionDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::clearSelection();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::clearSelection();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::clearSelection();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::clearSelection();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::clearSelection();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::clearSelection();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::clearSelection();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::clearSelection();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::clearSelection();
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::clearSelection();
	}
}

void QAbstractItemView_ConnectClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)(const QModelIndex &)>(&QAbstractItemView::clicked), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)(const QModelIndex &)>(&MyQAbstractItemView::Signal_Clicked), static_cast<Qt::ConnectionType>(t));
}

void QAbstractItemView_DisconnectClicked(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)(const QModelIndex &)>(&QAbstractItemView::clicked), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)(const QModelIndex &)>(&MyQAbstractItemView::Signal_Clicked));
}

void QAbstractItemView_Clicked(void* ptr, void* index)
{
	static_cast<QAbstractItemView*>(ptr)->clicked(*static_cast<QModelIndex*>(index));
}

void QAbstractItemView_CloseEditor(void* ptr, void* editor, long long hint)
{
		QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "closeEditor", Q_ARG(QWidget*, static_cast<QWidget*>(editor)), Q_ARG(QAbstractItemDelegate::EndEditHint, static_cast<QAbstractItemDelegate::EndEditHint>(hint)));
}

void QAbstractItemView_CloseEditorDefault(void* ptr, void* editor, long long hint)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
	}
}

void QAbstractItemView_ClosePersistentEditor(void* ptr, void* index)
{
	static_cast<QAbstractItemView*>(ptr)->closePersistentEditor(*static_cast<QModelIndex*>(index));
}

void QAbstractItemView_CommitData(void* ptr, void* editor)
{
		QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "commitData", Q_ARG(QWidget*, static_cast<QWidget*>(editor)));
}

void QAbstractItemView_CommitDataDefault(void* ptr, void* editor)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::commitData(static_cast<QWidget*>(editor));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::commitData(static_cast<QWidget*>(editor));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::commitData(static_cast<QWidget*>(editor));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::commitData(static_cast<QWidget*>(editor));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::commitData(static_cast<QWidget*>(editor));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::commitData(static_cast<QWidget*>(editor));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::commitData(static_cast<QWidget*>(editor));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::commitData(static_cast<QWidget*>(editor));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::commitData(static_cast<QWidget*>(editor));
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::commitData(static_cast<QWidget*>(editor));
	}
}

void QAbstractItemView_CurrentChanged(void* ptr, void* current, void* previous)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "currentChanged", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(current)), Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(previous)));
}

void QAbstractItemView_CurrentChangedDefault(void* ptr, void* current, void* previous)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	}
}

void* QAbstractItemView_CurrentIndex(void* ptr)
{
	return new QModelIndex(static_cast<QAbstractItemView*>(ptr)->currentIndex());
}

void QAbstractItemView_DataChanged(void* ptr, void* topLeft, void* bottomRight, void* roles)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "dataChanged", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(topLeft)), Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(bottomRight)), Q_ARG(const QVector<int>, *static_cast<QVector<int>*>(roles)));
}

void QAbstractItemView_DataChangedDefault(void* ptr, void* topLeft, void* bottomRight, void* roles)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	}
}

long long QAbstractItemView_DefaultDropAction(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->defaultDropAction();
}

void* QAbstractItemView_DirtyRegionOffset(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QAbstractItemView*>(ptr)->dirtyRegionOffset(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QAbstractItemView_ConnectDoubleClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)(const QModelIndex &)>(&QAbstractItemView::doubleClicked), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)(const QModelIndex &)>(&MyQAbstractItemView::Signal_DoubleClicked), static_cast<Qt::ConnectionType>(t));
}

void QAbstractItemView_DisconnectDoubleClicked(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)(const QModelIndex &)>(&QAbstractItemView::doubleClicked), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)(const QModelIndex &)>(&MyQAbstractItemView::Signal_DoubleClicked));
}

void QAbstractItemView_DoubleClicked(void* ptr, void* index)
{
	static_cast<QAbstractItemView*>(ptr)->doubleClicked(*static_cast<QModelIndex*>(index));
}

long long QAbstractItemView_DragDropMode(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->dragDropMode();
}

char QAbstractItemView_DragDropOverwriteMode(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->dragDropOverwriteMode();
}

char QAbstractItemView_DragEnabled(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->dragEnabled();
}

long long QAbstractItemView_DropIndicatorPosition(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->dropIndicatorPosition();
}

void QAbstractItemView_Edit(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "edit", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QAbstractItemView_EditDefault(void* ptr, void* index)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::edit(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::edit(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::edit(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::edit(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::edit(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::edit(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::edit(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::edit(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::edit(*static_cast<QModelIndex*>(index));
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::edit(*static_cast<QModelIndex*>(index));
	}
}

char QAbstractItemView_Edit2(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QAbstractItemView*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

char QAbstractItemView_Edit2Default(void* ptr, void* index, long long trigger, void* event)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeView*>(ptr)->QTreeView::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableView*>(ptr)->QTableView::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListView*>(ptr)->QListView::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHeaderView*>(ptr)->QHeaderView::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColumnView*>(ptr)->QColumnView::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
	}
}

long long QAbstractItemView_EditTriggers(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->editTriggers();
}

void QAbstractItemView_EditorDestroyed(void* ptr, void* editor)
{
		QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "editorDestroyed", Q_ARG(QObject*, static_cast<QObject*>(editor)));
}

void QAbstractItemView_EditorDestroyedDefault(void* ptr, void* editor)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(editor))) {
			static_cast<QTreeWidget*>(ptr)->QTreeWidget::editorDestroyed(static_cast<QGraphicsObject*>(editor));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QTreeWidget*>(ptr)->QTreeWidget::editorDestroyed(static_cast<QGraphicsWidget*>(editor));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(editor))) {
			static_cast<QTreeWidget*>(ptr)->QTreeWidget::editorDestroyed(static_cast<QLayout*>(editor));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QTreeWidget*>(ptr)->QTreeWidget::editorDestroyed(static_cast<QWidget*>(editor));
		} else {
			static_cast<QTreeWidget*>(ptr)->QTreeWidget::editorDestroyed(static_cast<QObject*>(editor));
		}
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(editor))) {
			static_cast<QTreeView*>(ptr)->QTreeView::editorDestroyed(static_cast<QGraphicsObject*>(editor));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QTreeView*>(ptr)->QTreeView::editorDestroyed(static_cast<QGraphicsWidget*>(editor));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(editor))) {
			static_cast<QTreeView*>(ptr)->QTreeView::editorDestroyed(static_cast<QLayout*>(editor));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QTreeView*>(ptr)->QTreeView::editorDestroyed(static_cast<QWidget*>(editor));
		} else {
			static_cast<QTreeView*>(ptr)->QTreeView::editorDestroyed(static_cast<QObject*>(editor));
		}
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(editor))) {
			static_cast<QTableWidget*>(ptr)->QTableWidget::editorDestroyed(static_cast<QGraphicsObject*>(editor));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QTableWidget*>(ptr)->QTableWidget::editorDestroyed(static_cast<QGraphicsWidget*>(editor));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(editor))) {
			static_cast<QTableWidget*>(ptr)->QTableWidget::editorDestroyed(static_cast<QLayout*>(editor));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QTableWidget*>(ptr)->QTableWidget::editorDestroyed(static_cast<QWidget*>(editor));
		} else {
			static_cast<QTableWidget*>(ptr)->QTableWidget::editorDestroyed(static_cast<QObject*>(editor));
		}
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(editor))) {
			static_cast<QTableView*>(ptr)->QTableView::editorDestroyed(static_cast<QGraphicsObject*>(editor));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QTableView*>(ptr)->QTableView::editorDestroyed(static_cast<QGraphicsWidget*>(editor));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(editor))) {
			static_cast<QTableView*>(ptr)->QTableView::editorDestroyed(static_cast<QLayout*>(editor));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QTableView*>(ptr)->QTableView::editorDestroyed(static_cast<QWidget*>(editor));
		} else {
			static_cast<QTableView*>(ptr)->QTableView::editorDestroyed(static_cast<QObject*>(editor));
		}
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(editor))) {
			static_cast<QUndoView*>(ptr)->QUndoView::editorDestroyed(static_cast<QGraphicsObject*>(editor));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QUndoView*>(ptr)->QUndoView::editorDestroyed(static_cast<QGraphicsWidget*>(editor));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(editor))) {
			static_cast<QUndoView*>(ptr)->QUndoView::editorDestroyed(static_cast<QLayout*>(editor));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QUndoView*>(ptr)->QUndoView::editorDestroyed(static_cast<QWidget*>(editor));
		} else {
			static_cast<QUndoView*>(ptr)->QUndoView::editorDestroyed(static_cast<QObject*>(editor));
		}
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(editor))) {
			static_cast<QListWidget*>(ptr)->QListWidget::editorDestroyed(static_cast<QGraphicsObject*>(editor));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QListWidget*>(ptr)->QListWidget::editorDestroyed(static_cast<QGraphicsWidget*>(editor));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(editor))) {
			static_cast<QListWidget*>(ptr)->QListWidget::editorDestroyed(static_cast<QLayout*>(editor));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QListWidget*>(ptr)->QListWidget::editorDestroyed(static_cast<QWidget*>(editor));
		} else {
			static_cast<QListWidget*>(ptr)->QListWidget::editorDestroyed(static_cast<QObject*>(editor));
		}
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(editor))) {
			static_cast<QListView*>(ptr)->QListView::editorDestroyed(static_cast<QGraphicsObject*>(editor));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QListView*>(ptr)->QListView::editorDestroyed(static_cast<QGraphicsWidget*>(editor));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(editor))) {
			static_cast<QListView*>(ptr)->QListView::editorDestroyed(static_cast<QLayout*>(editor));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QListView*>(ptr)->QListView::editorDestroyed(static_cast<QWidget*>(editor));
		} else {
			static_cast<QListView*>(ptr)->QListView::editorDestroyed(static_cast<QObject*>(editor));
		}
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(editor))) {
			static_cast<QHeaderView*>(ptr)->QHeaderView::editorDestroyed(static_cast<QGraphicsObject*>(editor));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QHeaderView*>(ptr)->QHeaderView::editorDestroyed(static_cast<QGraphicsWidget*>(editor));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(editor))) {
			static_cast<QHeaderView*>(ptr)->QHeaderView::editorDestroyed(static_cast<QLayout*>(editor));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QHeaderView*>(ptr)->QHeaderView::editorDestroyed(static_cast<QWidget*>(editor));
		} else {
			static_cast<QHeaderView*>(ptr)->QHeaderView::editorDestroyed(static_cast<QObject*>(editor));
		}
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(editor))) {
			static_cast<QColumnView*>(ptr)->QColumnView::editorDestroyed(static_cast<QGraphicsObject*>(editor));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QColumnView*>(ptr)->QColumnView::editorDestroyed(static_cast<QGraphicsWidget*>(editor));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(editor))) {
			static_cast<QColumnView*>(ptr)->QColumnView::editorDestroyed(static_cast<QLayout*>(editor));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QColumnView*>(ptr)->QColumnView::editorDestroyed(static_cast<QWidget*>(editor));
		} else {
			static_cast<QColumnView*>(ptr)->QColumnView::editorDestroyed(static_cast<QObject*>(editor));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(editor))) {
			static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::editorDestroyed(static_cast<QGraphicsObject*>(editor));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::editorDestroyed(static_cast<QGraphicsWidget*>(editor));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(editor))) {
			static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::editorDestroyed(static_cast<QLayout*>(editor));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(editor))) {
			static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::editorDestroyed(static_cast<QWidget*>(editor));
		} else {
			static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::editorDestroyed(static_cast<QObject*>(editor));
		}
	}
}

void QAbstractItemView_ConnectEntered(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)(const QModelIndex &)>(&QAbstractItemView::entered), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)(const QModelIndex &)>(&MyQAbstractItemView::Signal_Entered), static_cast<Qt::ConnectionType>(t));
}

void QAbstractItemView_DisconnectEntered(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)(const QModelIndex &)>(&QAbstractItemView::entered), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)(const QModelIndex &)>(&MyQAbstractItemView::Signal_Entered));
}

void QAbstractItemView_Entered(void* ptr, void* index)
{
	static_cast<QAbstractItemView*>(ptr)->entered(*static_cast<QModelIndex*>(index));
}

void QAbstractItemView_ExecuteDelayedItemsLayout(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->executeDelayedItemsLayout();
}

char QAbstractItemView_HasAutoScroll(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->hasAutoScroll();
}

int QAbstractItemView_HorizontalOffset(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->horizontalOffset();
}

long long QAbstractItemView_HorizontalScrollMode(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->horizontalScrollMode();
}

void* QAbstractItemView_IconSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QAbstractItemView*>(ptr)->iconSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QAbstractItemView_ConnectIconSizeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)(const QSize &)>(&QAbstractItemView::iconSizeChanged), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)(const QSize &)>(&MyQAbstractItemView::Signal_IconSizeChanged), static_cast<Qt::ConnectionType>(t));
}

void QAbstractItemView_DisconnectIconSizeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)(const QSize &)>(&QAbstractItemView::iconSizeChanged), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)(const QSize &)>(&MyQAbstractItemView::Signal_IconSizeChanged));
}

void QAbstractItemView_IconSizeChanged(void* ptr, void* size)
{
	static_cast<QAbstractItemView*>(ptr)->iconSizeChanged(*static_cast<QSize*>(size));
}

void* QAbstractItemView_IndexAt(void* ptr, void* point)
{
	return new QModelIndex(static_cast<QAbstractItemView*>(ptr)->indexAt(*static_cast<QPoint*>(point)));
}

void* QAbstractItemView_IndexWidget(void* ptr, void* index)
{
	return static_cast<QAbstractItemView*>(ptr)->indexWidget(*static_cast<QModelIndex*>(index));
}

char QAbstractItemView_IsIndexHidden(void* ptr, void* index)
{
	return static_cast<QAbstractItemView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}

char QAbstractItemView_IsPersistentEditorOpen(void* ptr, void* index)
{
	return static_cast<QAbstractItemView*>(ptr)->isPersistentEditorOpen(*static_cast<QModelIndex*>(index));
}

void* QAbstractItemView_ItemDelegate(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->itemDelegate();
}

void* QAbstractItemView_ItemDelegate2(void* ptr, void* index)
{
	return static_cast<QAbstractItemView*>(ptr)->itemDelegate(*static_cast<QModelIndex*>(index));
}

void* QAbstractItemView_ItemDelegateForColumn(void* ptr, int column)
{
	return static_cast<QAbstractItemView*>(ptr)->itemDelegateForColumn(column);
}

void* QAbstractItemView_ItemDelegateForRow(void* ptr, int row)
{
	return static_cast<QAbstractItemView*>(ptr)->itemDelegateForRow(row);
}

void QAbstractItemView_KeyboardSearch(void* ptr, struct QtWidgets_PackedString search)
{
	static_cast<QAbstractItemView*>(ptr)->keyboardSearch(QString::fromUtf8(search.data, search.len));
}

void QAbstractItemView_KeyboardSearchDefault(void* ptr, struct QtWidgets_PackedString search)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::keyboardSearch(QString::fromUtf8(search.data, search.len));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::keyboardSearch(QString::fromUtf8(search.data, search.len));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::keyboardSearch(QString::fromUtf8(search.data, search.len));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::keyboardSearch(QString::fromUtf8(search.data, search.len));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::keyboardSearch(QString::fromUtf8(search.data, search.len));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::keyboardSearch(QString::fromUtf8(search.data, search.len));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::keyboardSearch(QString::fromUtf8(search.data, search.len));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::keyboardSearch(QString::fromUtf8(search.data, search.len));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::keyboardSearch(QString::fromUtf8(search.data, search.len));
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::keyboardSearch(QString::fromUtf8(search.data, search.len));
	}
}

void* QAbstractItemView_Model(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->model();
}

void* QAbstractItemView_MoveCursor(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QAbstractItemView*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void QAbstractItemView_OpenPersistentEditor(void* ptr, void* index)
{
	static_cast<QAbstractItemView*>(ptr)->openPersistentEditor(*static_cast<QModelIndex*>(index));
}

void QAbstractItemView_ConnectPressed(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)(const QModelIndex &)>(&QAbstractItemView::pressed), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)(const QModelIndex &)>(&MyQAbstractItemView::Signal_Pressed), static_cast<Qt::ConnectionType>(t));
}

void QAbstractItemView_DisconnectPressed(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)(const QModelIndex &)>(&QAbstractItemView::pressed), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)(const QModelIndex &)>(&MyQAbstractItemView::Signal_Pressed));
}

void QAbstractItemView_Pressed(void* ptr, void* index)
{
	static_cast<QAbstractItemView*>(ptr)->pressed(*static_cast<QModelIndex*>(index));
}

void QAbstractItemView_Reset(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "reset");
}

void QAbstractItemView_ResetDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::reset();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::reset();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::reset();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::reset();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::reset();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::reset();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::reset();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::reset();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::reset();
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::reset();
	}
}

void QAbstractItemView_ResetHorizontalScrollMode(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->resetHorizontalScrollMode();
}

void QAbstractItemView_ResetVerticalScrollMode(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->resetVerticalScrollMode();
}

void* QAbstractItemView_RootIndex(void* ptr)
{
	return new QModelIndex(static_cast<QAbstractItemView*>(ptr)->rootIndex());
}

void QAbstractItemView_RowsAboutToBeRemoved(void* ptr, void* parent, int start, int end)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "rowsAboutToBeRemoved", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
}

void QAbstractItemView_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	}
}

void QAbstractItemView_RowsInserted(void* ptr, void* parent, int start, int end)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "rowsInserted", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
}

void QAbstractItemView_RowsInsertedDefault(void* ptr, void* parent, int start, int end)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	}
}

void QAbstractItemView_ScheduleDelayedItemsLayout(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->scheduleDelayedItemsLayout();
}

void QAbstractItemView_ScrollDirtyRegion(void* ptr, int dx, int dy)
{
	static_cast<QAbstractItemView*>(ptr)->scrollDirtyRegion(dx, dy);
}

void QAbstractItemView_ScrollTo(void* ptr, void* index, long long hint)
{
	static_cast<QAbstractItemView*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QAbstractItemView_ScrollToBottom(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "scrollToBottom");
}

void QAbstractItemView_ScrollToBottomDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::scrollToBottom();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::scrollToBottom();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::scrollToBottom();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::scrollToBottom();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::scrollToBottom();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::scrollToBottom();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::scrollToBottom();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::scrollToBottom();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::scrollToBottom();
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::scrollToBottom();
	}
}

void QAbstractItemView_ScrollToTop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "scrollToTop");
}

void QAbstractItemView_ScrollToTopDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::scrollToTop();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::scrollToTop();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::scrollToTop();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::scrollToTop();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::scrollToTop();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::scrollToTop();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::scrollToTop();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::scrollToTop();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::scrollToTop();
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::scrollToTop();
	}
}

void QAbstractItemView_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "selectAll");
}

void QAbstractItemView_SelectAllDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::selectAll();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::selectAll();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::selectAll();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::selectAll();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::selectAll();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::selectAll();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::selectAll();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::selectAll();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::selectAll();
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::selectAll();
	}
}

struct QtWidgets_PackedList QAbstractItemView_SelectedIndexes(void* ptr)
{
	return ({ QList<QModelIndex>* tmpValue765a4d = new QList<QModelIndex>(static_cast<QAbstractItemView*>(ptr)->selectedIndexes()); QtWidgets_PackedList { tmpValue765a4d, tmpValue765a4d->size() }; });
}

struct QtWidgets_PackedList QAbstractItemView_SelectedIndexesDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QModelIndex>* tmpValuec60d90 = new QList<QModelIndex>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::selectedIndexes()); QtWidgets_PackedList { tmpValuec60d90, tmpValuec60d90->size() }; });
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QModelIndex>* tmpValuec60d90 = new QList<QModelIndex>(static_cast<QTreeView*>(ptr)->QTreeView::selectedIndexes()); QtWidgets_PackedList { tmpValuec60d90, tmpValuec60d90->size() }; });
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QModelIndex>* tmpValuec60d90 = new QList<QModelIndex>(static_cast<QTableWidget*>(ptr)->QTableWidget::selectedIndexes()); QtWidgets_PackedList { tmpValuec60d90, tmpValuec60d90->size() }; });
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QModelIndex>* tmpValuec60d90 = new QList<QModelIndex>(static_cast<QTableView*>(ptr)->QTableView::selectedIndexes()); QtWidgets_PackedList { tmpValuec60d90, tmpValuec60d90->size() }; });
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QModelIndex>* tmpValuec60d90 = new QList<QModelIndex>(static_cast<QUndoView*>(ptr)->QUndoView::selectedIndexes()); QtWidgets_PackedList { tmpValuec60d90, tmpValuec60d90->size() }; });
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QModelIndex>* tmpValuec60d90 = new QList<QModelIndex>(static_cast<QListWidget*>(ptr)->QListWidget::selectedIndexes()); QtWidgets_PackedList { tmpValuec60d90, tmpValuec60d90->size() }; });
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QModelIndex>* tmpValuec60d90 = new QList<QModelIndex>(static_cast<QListView*>(ptr)->QListView::selectedIndexes()); QtWidgets_PackedList { tmpValuec60d90, tmpValuec60d90->size() }; });
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QModelIndex>* tmpValuec60d90 = new QList<QModelIndex>(static_cast<QHeaderView*>(ptr)->QHeaderView::selectedIndexes()); QtWidgets_PackedList { tmpValuec60d90, tmpValuec60d90->size() }; });
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QModelIndex>* tmpValuec60d90 = new QList<QModelIndex>(static_cast<QColumnView*>(ptr)->QColumnView::selectedIndexes()); QtWidgets_PackedList { tmpValuec60d90, tmpValuec60d90->size() }; });
	} else {
		return ({ QList<QModelIndex>* tmpValuec60d90 = new QList<QModelIndex>(static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::selectedIndexes()); QtWidgets_PackedList { tmpValuec60d90, tmpValuec60d90->size() }; });
	}
}

long long QAbstractItemView_SelectionBehavior(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->selectionBehavior();
}

void QAbstractItemView_SelectionChanged(void* ptr, void* selected, void* deselected)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "selectionChanged", Q_ARG(const QItemSelection, *static_cast<QItemSelection*>(selected)), Q_ARG(const QItemSelection, *static_cast<QItemSelection*>(deselected)));
}

void QAbstractItemView_SelectionChangedDefault(void* ptr, void* selected, void* deselected)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	}
}

long long QAbstractItemView_SelectionCommand(void* ptr, void* index, void* event)
{
	return static_cast<QAbstractItemView*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

long long QAbstractItemView_SelectionCommandDefault(void* ptr, void* index, void* event)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeView*>(ptr)->QTreeView::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableView*>(ptr)->QTableView::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListView*>(ptr)->QListView::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHeaderView*>(ptr)->QHeaderView::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColumnView*>(ptr)->QColumnView::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
	}
}

long long QAbstractItemView_SelectionMode(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->selectionMode();
}

void* QAbstractItemView_SelectionModel(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->selectionModel();
}

void QAbstractItemView_SetAlternatingRowColors(void* ptr, char enable)
{
	static_cast<QAbstractItemView*>(ptr)->setAlternatingRowColors(enable != 0);
}

void QAbstractItemView_SetAutoScroll(void* ptr, char enable)
{
	static_cast<QAbstractItemView*>(ptr)->setAutoScroll(enable != 0);
}

void QAbstractItemView_SetAutoScrollMargin(void* ptr, int margin)
{
	static_cast<QAbstractItemView*>(ptr)->setAutoScrollMargin(margin);
}

void QAbstractItemView_SetCurrentIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "setCurrentIndex", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QAbstractItemView_SetCurrentIndexDefault(void* ptr, void* index)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setCurrentIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::setCurrentIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setCurrentIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::setCurrentIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setCurrentIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setCurrentIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::setCurrentIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::setCurrentIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::setCurrentIndex(*static_cast<QModelIndex*>(index));
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setCurrentIndex(*static_cast<QModelIndex*>(index));
	}
}

void QAbstractItemView_SetDefaultDropAction(void* ptr, long long dropAction)
{
	static_cast<QAbstractItemView*>(ptr)->setDefaultDropAction(static_cast<Qt::DropAction>(dropAction));
}

void QAbstractItemView_SetDirtyRegion(void* ptr, void* region)
{
	static_cast<QAbstractItemView*>(ptr)->setDirtyRegion(*static_cast<QRegion*>(region));
}

void QAbstractItemView_SetDragDropMode(void* ptr, long long behavior)
{
	static_cast<QAbstractItemView*>(ptr)->setDragDropMode(static_cast<QAbstractItemView::DragDropMode>(behavior));
}

void QAbstractItemView_SetDragDropOverwriteMode(void* ptr, char overwrite)
{
	static_cast<QAbstractItemView*>(ptr)->setDragDropOverwriteMode(overwrite != 0);
}

void QAbstractItemView_SetDragEnabled(void* ptr, char enable)
{
	static_cast<QAbstractItemView*>(ptr)->setDragEnabled(enable != 0);
}

void QAbstractItemView_SetDropIndicatorShown(void* ptr, char enable)
{
	static_cast<QAbstractItemView*>(ptr)->setDropIndicatorShown(enable != 0);
}

void QAbstractItemView_SetEditTriggers(void* ptr, long long triggers)
{
	static_cast<QAbstractItemView*>(ptr)->setEditTriggers(static_cast<QAbstractItemView::EditTrigger>(triggers));
}

void QAbstractItemView_SetHorizontalScrollMode(void* ptr, long long mode)
{
	static_cast<QAbstractItemView*>(ptr)->setHorizontalScrollMode(static_cast<QAbstractItemView::ScrollMode>(mode));
}

void QAbstractItemView_SetIconSize(void* ptr, void* size)
{
	static_cast<QAbstractItemView*>(ptr)->setIconSize(*static_cast<QSize*>(size));
}

void QAbstractItemView_SetIndexWidget(void* ptr, void* index, void* widget)
{
		static_cast<QAbstractItemView*>(ptr)->setIndexWidget(*static_cast<QModelIndex*>(index), static_cast<QWidget*>(widget));
}

void QAbstractItemView_SetItemDelegate(void* ptr, void* delegate)
{
	static_cast<QAbstractItemView*>(ptr)->setItemDelegate(static_cast<QAbstractItemDelegate*>(delegate));
}

void QAbstractItemView_SetItemDelegateForColumn(void* ptr, int column, void* delegate)
{
	static_cast<QAbstractItemView*>(ptr)->setItemDelegateForColumn(column, static_cast<QAbstractItemDelegate*>(delegate));
}

void QAbstractItemView_SetItemDelegateForRow(void* ptr, int row, void* delegate)
{
	static_cast<QAbstractItemView*>(ptr)->setItemDelegateForRow(row, static_cast<QAbstractItemDelegate*>(delegate));
}

void QAbstractItemView_SetModel(void* ptr, void* model)
{
	static_cast<QAbstractItemView*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}

void QAbstractItemView_SetModelDefault(void* ptr, void* model)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setModel(static_cast<QAbstractItemModel*>(model));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::setModel(static_cast<QAbstractItemModel*>(model));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setModel(static_cast<QAbstractItemModel*>(model));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::setModel(static_cast<QAbstractItemModel*>(model));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setModel(static_cast<QAbstractItemModel*>(model));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setModel(static_cast<QAbstractItemModel*>(model));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::setModel(static_cast<QAbstractItemModel*>(model));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::setModel(static_cast<QAbstractItemModel*>(model));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::setModel(static_cast<QAbstractItemModel*>(model));
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setModel(static_cast<QAbstractItemModel*>(model));
	}
}

void QAbstractItemView_SetRootIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "setRootIndex", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QAbstractItemView_SetRootIndexDefault(void* ptr, void* index)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setRootIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::setRootIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setRootIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::setRootIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setRootIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setRootIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::setRootIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::setRootIndex(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::setRootIndex(*static_cast<QModelIndex*>(index));
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setRootIndex(*static_cast<QModelIndex*>(index));
	}
}

void QAbstractItemView_SetSelection(void* ptr, void* rect, long long flags)
{
	static_cast<QAbstractItemView*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
}

void QAbstractItemView_SetSelectionBehavior(void* ptr, long long behavior)
{
	static_cast<QAbstractItemView*>(ptr)->setSelectionBehavior(static_cast<QAbstractItemView::SelectionBehavior>(behavior));
}

void QAbstractItemView_SetSelectionMode(void* ptr, long long mode)
{
	static_cast<QAbstractItemView*>(ptr)->setSelectionMode(static_cast<QAbstractItemView::SelectionMode>(mode));
}

void QAbstractItemView_SetSelectionModel(void* ptr, void* selectionModel)
{
	static_cast<QAbstractItemView*>(ptr)->setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

void QAbstractItemView_SetSelectionModelDefault(void* ptr, void* selectionModel)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
	}
}

void QAbstractItemView_SetState(void* ptr, long long state)
{
	static_cast<QAbstractItemView*>(ptr)->setState(static_cast<QAbstractItemView::State>(state));
}

void QAbstractItemView_SetTabKeyNavigation(void* ptr, char enable)
{
	static_cast<QAbstractItemView*>(ptr)->setTabKeyNavigation(enable != 0);
}

void QAbstractItemView_SetTextElideMode(void* ptr, long long mode)
{
	static_cast<QAbstractItemView*>(ptr)->setTextElideMode(static_cast<Qt::TextElideMode>(mode));
}

void QAbstractItemView_SetVerticalScrollMode(void* ptr, long long mode)
{
	static_cast<QAbstractItemView*>(ptr)->setVerticalScrollMode(static_cast<QAbstractItemView::ScrollMode>(mode));
}

char QAbstractItemView_ShowDropIndicator(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->showDropIndicator();
}

int QAbstractItemView_SizeHintForColumn(void* ptr, int column)
{
	return static_cast<QAbstractItemView*>(ptr)->sizeHintForColumn(column);
}

int QAbstractItemView_SizeHintForColumnDefault(void* ptr, int column)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::sizeHintForColumn(column);
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeView*>(ptr)->QTreeView::sizeHintForColumn(column);
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::sizeHintForColumn(column);
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableView*>(ptr)->QTableView::sizeHintForColumn(column);
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::sizeHintForColumn(column);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::sizeHintForColumn(column);
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListView*>(ptr)->QListView::sizeHintForColumn(column);
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHeaderView*>(ptr)->QHeaderView::sizeHintForColumn(column);
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColumnView*>(ptr)->QColumnView::sizeHintForColumn(column);
	} else {
		return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::sizeHintForColumn(column);
	}
}

void* QAbstractItemView_SizeHintForIndex(void* ptr, void* index)
{
	return ({ QSize tmpValue = static_cast<QAbstractItemView*>(ptr)->sizeHintForIndex(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QAbstractItemView_SizeHintForRow(void* ptr, int row)
{
	return static_cast<QAbstractItemView*>(ptr)->sizeHintForRow(row);
}

int QAbstractItemView_SizeHintForRowDefault(void* ptr, int row)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::sizeHintForRow(row);
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeView*>(ptr)->QTreeView::sizeHintForRow(row);
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::sizeHintForRow(row);
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableView*>(ptr)->QTableView::sizeHintForRow(row);
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::sizeHintForRow(row);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::sizeHintForRow(row);
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListView*>(ptr)->QListView::sizeHintForRow(row);
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHeaderView*>(ptr)->QHeaderView::sizeHintForRow(row);
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColumnView*>(ptr)->QColumnView::sizeHintForRow(row);
	} else {
		return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::sizeHintForRow(row);
	}
}

void QAbstractItemView_StartDrag(void* ptr, long long supportedActions)
{
	static_cast<QAbstractItemView*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QAbstractItemView_StartDragDefault(void* ptr, long long supportedActions)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::startDrag(static_cast<Qt::DropAction>(supportedActions));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::startDrag(static_cast<Qt::DropAction>(supportedActions));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::startDrag(static_cast<Qt::DropAction>(supportedActions));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::startDrag(static_cast<Qt::DropAction>(supportedActions));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::startDrag(static_cast<Qt::DropAction>(supportedActions));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::startDrag(static_cast<Qt::DropAction>(supportedActions));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::startDrag(static_cast<Qt::DropAction>(supportedActions));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::startDrag(static_cast<Qt::DropAction>(supportedActions));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::startDrag(static_cast<Qt::DropAction>(supportedActions));
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::startDrag(static_cast<Qt::DropAction>(supportedActions));
	}
}

long long QAbstractItemView_State(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->state();
}

char QAbstractItemView_TabKeyNavigation(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->tabKeyNavigation();
}

long long QAbstractItemView_TextElideMode(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->textElideMode();
}

void QAbstractItemView_Update(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "update", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QAbstractItemView_UpdateDefault(void* ptr, void* index)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::update(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::update(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::update(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::update(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::update(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::update(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::update(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::update(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::update(*static_cast<QModelIndex*>(index));
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::update(*static_cast<QModelIndex*>(index));
	}
}

void QAbstractItemView_UpdateGeometries(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "updateGeometries");
}

void QAbstractItemView_UpdateGeometriesDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::updateGeometries();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::updateGeometries();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::updateGeometries();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::updateGeometries();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::updateGeometries();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::updateGeometries();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::updateGeometries();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::updateGeometries();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::updateGeometries();
	} else {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::updateGeometries();
	}
}

int QAbstractItemView_VerticalOffset(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->verticalOffset();
}

long long QAbstractItemView_VerticalScrollMode(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->verticalScrollMode();
}

void* QAbstractItemView_ViewOptions(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QAbstractItemView*>(ptr)->viewOptions());
}

void* QAbstractItemView_ViewOptionsDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return new QStyleOptionViewItem(static_cast<QTreeWidget*>(ptr)->QTreeWidget::viewOptions());
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return new QStyleOptionViewItem(static_cast<QTreeView*>(ptr)->QTreeView::viewOptions());
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return new QStyleOptionViewItem(static_cast<QTableWidget*>(ptr)->QTableWidget::viewOptions());
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return new QStyleOptionViewItem(static_cast<QTableView*>(ptr)->QTableView::viewOptions());
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return new QStyleOptionViewItem(static_cast<QUndoView*>(ptr)->QUndoView::viewOptions());
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return new QStyleOptionViewItem(static_cast<QListWidget*>(ptr)->QListWidget::viewOptions());
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return new QStyleOptionViewItem(static_cast<QListView*>(ptr)->QListView::viewOptions());
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return new QStyleOptionViewItem(static_cast<QHeaderView*>(ptr)->QHeaderView::viewOptions());
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return new QStyleOptionViewItem(static_cast<QColumnView*>(ptr)->QColumnView::viewOptions());
	} else {
		return new QStyleOptionViewItem(static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::viewOptions());
	}
}

void QAbstractItemView_ConnectViewportEntered(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)()>(&QAbstractItemView::viewportEntered), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)()>(&MyQAbstractItemView::Signal_ViewportEntered), static_cast<Qt::ConnectionType>(t));
}

void QAbstractItemView_DisconnectViewportEntered(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractItemView*>(ptr), static_cast<void (QAbstractItemView::*)()>(&QAbstractItemView::viewportEntered), static_cast<MyQAbstractItemView*>(ptr), static_cast<void (MyQAbstractItemView::*)()>(&MyQAbstractItemView::Signal_ViewportEntered));
}

void QAbstractItemView_ViewportEntered(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->viewportEntered();
}

void* QAbstractItemView_VisualRect(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QAbstractItemView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QAbstractItemView_VisualRegionForSelection(void* ptr, void* selection)
{
	return new QRegion(static_cast<QAbstractItemView*>(ptr)->visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void QAbstractItemView_DestroyQAbstractItemView(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->~QAbstractItemView();
}

void QAbstractItemView_DestroyQAbstractItemViewDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

int QAbstractItemView___dataChanged_roles_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QVector<int>*>(ptr)->at(i); if (i == static_cast<QVector<int>*>(ptr)->size()-1) { static_cast<QVector<int>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}

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

void* QAbstractItemView___dataChanged_roles_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<int>();
}

void* QAbstractItemView___selectedIndexes_atList(void* ptr, int i)
{
	return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QAbstractItemView___selectedIndexes_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QModelIndex>();
}

class MyQAbstractScrollArea: public QAbstractScrollArea
{
public:
	MyQAbstractScrollArea(QWidget *parent = Q_NULLPTR) : QAbstractScrollArea(parent) {QAbstractScrollArea_QAbstractScrollArea_QRegisterMetaType();};
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQWidget_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	 ~MyQAbstractScrollArea() { callbackQAbstractScrollArea_DestroyQAbstractScrollArea(this); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAbstractScrollArea*)
Q_DECLARE_METATYPE(MyQAbstractScrollArea*)

int QAbstractScrollArea_QAbstractScrollArea_QRegisterMetaType(){qRegisterMetaType<QAbstractScrollArea*>(); return qRegisterMetaType<MyQAbstractScrollArea*>();}

void* QAbstractScrollArea_NewQAbstractScrollArea(void* parent)
{
		return new MyQAbstractScrollArea(static_cast<QWidget*>(parent));
}

void QAbstractScrollArea_AddScrollBarWidget(void* ptr, void* widget, long long alignment)
{
		static_cast<QAbstractScrollArea*>(ptr)->addScrollBarWidget(static_cast<QWidget*>(widget), static_cast<Qt::AlignmentFlag>(alignment));
}

void* QAbstractScrollArea_CornerWidget(void* ptr)
{
	return static_cast<QAbstractScrollArea*>(ptr)->cornerWidget();
}

void* QAbstractScrollArea_HorizontalScrollBar(void* ptr)
{
	return static_cast<QAbstractScrollArea*>(ptr)->horizontalScrollBar();
}

long long QAbstractScrollArea_HorizontalScrollBarPolicy(void* ptr)
{
	return static_cast<QAbstractScrollArea*>(ptr)->horizontalScrollBarPolicy();
}

void* QAbstractScrollArea_MaximumViewportSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QAbstractScrollArea*>(ptr)->maximumViewportSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

struct QtWidgets_PackedList QAbstractScrollArea_ScrollBarWidgets(void* ptr, long long alignment)
{
	return ({ QList<QWidget *>* tmpValue2f39ff = new QList<QWidget *>(static_cast<QAbstractScrollArea*>(ptr)->scrollBarWidgets(static_cast<Qt::AlignmentFlag>(alignment))); QtWidgets_PackedList { tmpValue2f39ff, tmpValue2f39ff->size() }; });
}

void QAbstractScrollArea_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QAbstractScrollArea*>(ptr)->scrollContentsBy(dx, dy);
}

void QAbstractScrollArea_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::scrollContentsBy(dx, dy);
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::scrollContentsBy(dx, dy);
	} else {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::scrollContentsBy(dx, dy);
	}
}

void QAbstractScrollArea_SetCornerWidget(void* ptr, void* widget)
{
		static_cast<QAbstractScrollArea*>(ptr)->setCornerWidget(static_cast<QWidget*>(widget));
}

void QAbstractScrollArea_SetHorizontalScrollBar(void* ptr, void* scrollBar)
{
	static_cast<QAbstractScrollArea*>(ptr)->setHorizontalScrollBar(static_cast<QScrollBar*>(scrollBar));
}

void QAbstractScrollArea_SetHorizontalScrollBarPolicy(void* ptr, long long vqt)
{
	static_cast<QAbstractScrollArea*>(ptr)->setHorizontalScrollBarPolicy(static_cast<Qt::ScrollBarPolicy>(vqt));
}

void QAbstractScrollArea_SetSizeAdjustPolicy(void* ptr, long long policy)
{
	static_cast<QAbstractScrollArea*>(ptr)->setSizeAdjustPolicy(static_cast<QAbstractScrollArea::SizeAdjustPolicy>(policy));
}

void QAbstractScrollArea_SetVerticalScrollBar(void* ptr, void* scrollBar)
{
	static_cast<QAbstractScrollArea*>(ptr)->setVerticalScrollBar(static_cast<QScrollBar*>(scrollBar));
}

void QAbstractScrollArea_SetVerticalScrollBarPolicy(void* ptr, long long vqt)
{
	static_cast<QAbstractScrollArea*>(ptr)->setVerticalScrollBarPolicy(static_cast<Qt::ScrollBarPolicy>(vqt));
}

void QAbstractScrollArea_SetViewport(void* ptr, void* widget)
{
		static_cast<QAbstractScrollArea*>(ptr)->setViewport(static_cast<QWidget*>(widget));
}

void QAbstractScrollArea_SetViewportMargins(void* ptr, int left, int top, int right, int bottom)
{
	static_cast<QAbstractScrollArea*>(ptr)->setViewportMargins(left, top, right, bottom);
}

void QAbstractScrollArea_SetViewportMargins2(void* ptr, void* margins)
{
	static_cast<QAbstractScrollArea*>(ptr)->setViewportMargins(*static_cast<QMargins*>(margins));
}

void QAbstractScrollArea_SetupViewport(void* ptr, void* viewport)
{
		static_cast<QAbstractScrollArea*>(ptr)->setupViewport(static_cast<QWidget*>(viewport));
}

void QAbstractScrollArea_SetupViewportDefault(void* ptr, void* viewport)
{
	if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::setupViewport(static_cast<QWidget*>(viewport));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setupViewport(static_cast<QWidget*>(viewport));
	} else {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setupViewport(static_cast<QWidget*>(viewport));
	}
}

long long QAbstractScrollArea_SizeAdjustPolicy(void* ptr)
{
	return static_cast<QAbstractScrollArea*>(ptr)->sizeAdjustPolicy();
}

void* QAbstractScrollArea_VerticalScrollBar(void* ptr)
{
	return static_cast<QAbstractScrollArea*>(ptr)->verticalScrollBar();
}

long long QAbstractScrollArea_VerticalScrollBarPolicy(void* ptr)
{
	return static_cast<QAbstractScrollArea*>(ptr)->verticalScrollBarPolicy();
}

void* QAbstractScrollArea_Viewport(void* ptr)
{
	return static_cast<QAbstractScrollArea*>(ptr)->viewport();
}

char QAbstractScrollArea_ViewportEvent(void* ptr, void* event)
{
	return static_cast<QAbstractScrollArea*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}

char QAbstractScrollArea_ViewportEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextBrowser*>(ptr)->QTextBrowser::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextEdit*>(ptr)->QTextEdit::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiArea*>(ptr)->QMdiArea::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsView*>(ptr)->QGraphicsView::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollArea*>(ptr)->QScrollArea::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeView*>(ptr)->QTreeView::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableView*>(ptr)->QTableView::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListView*>(ptr)->QListView::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHeaderView*>(ptr)->QHeaderView::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColumnView*>(ptr)->QColumnView::viewportEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::viewportEvent(static_cast<QEvent*>(event));
	} else {
		return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::viewportEvent(static_cast<QEvent*>(event));
	}
}

void* QAbstractScrollArea_ViewportMargins(void* ptr)
{
	return ({ QMargins tmpValue = static_cast<QAbstractScrollArea*>(ptr)->viewportMargins(); new QMargins(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}

void* QAbstractScrollArea_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QAbstractScrollArea*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QAbstractScrollArea_ViewportSizeHintDefault(void* ptr)
{
	if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTextBrowser*>(ptr)->QTextBrowser::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTextEdit*>(ptr)->QTextEdit::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QMdiArea*>(ptr)->QMdiArea::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QGraphicsView*>(ptr)->QGraphicsView::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QScrollArea*>(ptr)->QScrollArea::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTreeWidget*>(ptr)->QTreeWidget::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTreeView*>(ptr)->QTreeView::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTableWidget*>(ptr)->QTableWidget::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTableView*>(ptr)->QTableView::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QUndoView*>(ptr)->QUndoView::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QListWidget*>(ptr)->QListWidget::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QListView*>(ptr)->QListView::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QHeaderView*>(ptr)->QHeaderView::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QColumnView*>(ptr)->QColumnView::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void QAbstractScrollArea_DestroyQAbstractScrollArea(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->~QAbstractScrollArea();
}

void QAbstractScrollArea_DestroyQAbstractScrollAreaDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QAbstractScrollArea___scrollBarWidgets_atList(void* ptr, int i)
{
	return ({QWidget * tmp = static_cast<QList<QWidget *>*>(ptr)->at(i); if (i == static_cast<QList<QWidget *>*>(ptr)->size()-1) { static_cast<QList<QWidget *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QAbstractScrollArea___scrollBarWidgets_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QWidget *>();
}

class MyQAbstractSlider: public QAbstractSlider
{
public:
	MyQAbstractSlider(QWidget *parent = Q_NULLPTR) : QAbstractSlider(parent) {QAbstractSlider_QAbstractSlider_QRegisterMetaType();};
	void Signal_ActionTriggered(int action) { callbackQAbstractSlider_ActionTriggered(this, action); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void keyPressEvent(QKeyEvent * ev) { callbackQWidget_KeyPressEvent(this, ev); };
	void Signal_RangeChanged(int min, int max) { callbackQAbstractSlider_RangeChanged(this, min, max); };
	void setOrientation(Qt::Orientation vqt) { callbackQAbstractSlider_SetOrientation(this, vqt); };
	void setRange(int min, int max) { callbackQAbstractSlider_SetRange(this, min, max); };
	void setValue(int vin) { callbackQAbstractSlider_SetValue(this, vin); };
	void sliderChange(QAbstractSlider::SliderChange change) { callbackQAbstractSlider_SliderChange(this, change); };
	void Signal_SliderMoved(int value) { callbackQAbstractSlider_SliderMoved(this, value); };
	void Signal_SliderPressed() { callbackQAbstractSlider_SliderPressed(this); };
	void Signal_SliderReleased() { callbackQAbstractSlider_SliderReleased(this); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void Signal_ValueChanged(int value) { callbackQAbstractSlider_ValueChanged(this, value); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	 ~MyQAbstractSlider() { callbackQAbstractSlider_DestroyQAbstractSlider(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QAbstractSlider*)
Q_DECLARE_METATYPE(MyQAbstractSlider*)

int QAbstractSlider_QAbstractSlider_QRegisterMetaType(){qRegisterMetaType<QAbstractSlider*>(); return qRegisterMetaType<MyQAbstractSlider*>();}

void* QAbstractSlider_NewQAbstractSlider(void* parent)
{
		return new MyQAbstractSlider(static_cast<QWidget*>(parent));
}

void QAbstractSlider_ConnectActionTriggered(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractSlider*>(ptr), static_cast<void (QAbstractSlider::*)(int)>(&QAbstractSlider::actionTriggered), static_cast<MyQAbstractSlider*>(ptr), static_cast<void (MyQAbstractSlider::*)(int)>(&MyQAbstractSlider::Signal_ActionTriggered), static_cast<Qt::ConnectionType>(t));
}

void QAbstractSlider_DisconnectActionTriggered(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractSlider*>(ptr), static_cast<void (QAbstractSlider::*)(int)>(&QAbstractSlider::actionTriggered), static_cast<MyQAbstractSlider*>(ptr), static_cast<void (MyQAbstractSlider::*)(int)>(&MyQAbstractSlider::Signal_ActionTriggered));
}

void QAbstractSlider_ActionTriggered(void* ptr, int action)
{
	static_cast<QAbstractSlider*>(ptr)->actionTriggered(action);
}

char QAbstractSlider_HasTracking(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->hasTracking();
}

char QAbstractSlider_InvertedAppearance(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->invertedAppearance();
}

char QAbstractSlider_InvertedControls(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->invertedControls();
}

char QAbstractSlider_IsSliderDown(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->isSliderDown();
}

int QAbstractSlider_Maximum(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->maximum();
}

int QAbstractSlider_Minimum(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->minimum();
}

long long QAbstractSlider_Orientation(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->orientation();
}

int QAbstractSlider_PageStep(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->pageStep();
}

void QAbstractSlider_ConnectRangeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractSlider*>(ptr), static_cast<void (QAbstractSlider::*)(int, int)>(&QAbstractSlider::rangeChanged), static_cast<MyQAbstractSlider*>(ptr), static_cast<void (MyQAbstractSlider::*)(int, int)>(&MyQAbstractSlider::Signal_RangeChanged), static_cast<Qt::ConnectionType>(t));
}

void QAbstractSlider_DisconnectRangeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractSlider*>(ptr), static_cast<void (QAbstractSlider::*)(int, int)>(&QAbstractSlider::rangeChanged), static_cast<MyQAbstractSlider*>(ptr), static_cast<void (MyQAbstractSlider::*)(int, int)>(&MyQAbstractSlider::Signal_RangeChanged));
}

void QAbstractSlider_RangeChanged(void* ptr, int min, int max)
{
	static_cast<QAbstractSlider*>(ptr)->rangeChanged(min, max);
}

long long QAbstractSlider_RepeatAction(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->repeatAction();
}

void QAbstractSlider_SetInvertedAppearance(void* ptr, char vbo)
{
	static_cast<QAbstractSlider*>(ptr)->setInvertedAppearance(vbo != 0);
}

void QAbstractSlider_SetInvertedControls(void* ptr, char vbo)
{
	static_cast<QAbstractSlider*>(ptr)->setInvertedControls(vbo != 0);
}

void QAbstractSlider_SetMaximum(void* ptr, int vin)
{
	static_cast<QAbstractSlider*>(ptr)->setMaximum(vin);
}

void QAbstractSlider_SetMinimum(void* ptr, int vin)
{
	static_cast<QAbstractSlider*>(ptr)->setMinimum(vin);
}

void QAbstractSlider_SetOrientation(void* ptr, long long vqt)
{
	qRegisterMetaType<Qt::Orientation>();
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setOrientation", Q_ARG(Qt::Orientation, static_cast<Qt::Orientation>(vqt)));
}

void QAbstractSlider_SetOrientationDefault(void* ptr, long long vqt)
{
	if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::setOrientation(static_cast<Qt::Orientation>(vqt));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::setOrientation(static_cast<Qt::Orientation>(vqt));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::setOrientation(static_cast<Qt::Orientation>(vqt));
	} else {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setOrientation(static_cast<Qt::Orientation>(vqt));
	}
}

void QAbstractSlider_SetPageStep(void* ptr, int vin)
{
	static_cast<QAbstractSlider*>(ptr)->setPageStep(vin);
}

void QAbstractSlider_SetRange(void* ptr, int min, int max)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setRange", Q_ARG(int, min), Q_ARG(int, max));
}

void QAbstractSlider_SetRangeDefault(void* ptr, int min, int max)
{
	if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::setRange(min, max);
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::setRange(min, max);
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::setRange(min, max);
	} else {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setRange(min, max);
	}
}

void QAbstractSlider_SetRepeatAction(void* ptr, long long action, int thresholdTime, int repeatTime)
{
	static_cast<QAbstractSlider*>(ptr)->setRepeatAction(static_cast<QAbstractSlider::SliderAction>(action), thresholdTime, repeatTime);
}

void QAbstractSlider_SetSingleStep(void* ptr, int vin)
{
	static_cast<QAbstractSlider*>(ptr)->setSingleStep(vin);
}

void QAbstractSlider_SetSliderDown(void* ptr, char vbo)
{
	static_cast<QAbstractSlider*>(ptr)->setSliderDown(vbo != 0);
}

void QAbstractSlider_SetSliderPosition(void* ptr, int vin)
{
	static_cast<QAbstractSlider*>(ptr)->setSliderPosition(vin);
}

void QAbstractSlider_SetTracking(void* ptr, char enable)
{
	static_cast<QAbstractSlider*>(ptr)->setTracking(enable != 0);
}

void QAbstractSlider_SetValue(void* ptr, int vin)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setValue", Q_ARG(int, vin));
}

void QAbstractSlider_SetValueDefault(void* ptr, int vin)
{
	if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::setValue(vin);
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::setValue(vin);
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::setValue(vin);
	} else {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setValue(vin);
	}
}

int QAbstractSlider_SingleStep(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->singleStep();
}

void QAbstractSlider_SliderChange(void* ptr, long long change)
{
	static_cast<QAbstractSlider*>(ptr)->sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
}

void QAbstractSlider_SliderChangeDefault(void* ptr, long long change)
{
	if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
	} else {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
	}
}

void QAbstractSlider_ConnectSliderMoved(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractSlider*>(ptr), static_cast<void (QAbstractSlider::*)(int)>(&QAbstractSlider::sliderMoved), static_cast<MyQAbstractSlider*>(ptr), static_cast<void (MyQAbstractSlider::*)(int)>(&MyQAbstractSlider::Signal_SliderMoved), static_cast<Qt::ConnectionType>(t));
}

void QAbstractSlider_DisconnectSliderMoved(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractSlider*>(ptr), static_cast<void (QAbstractSlider::*)(int)>(&QAbstractSlider::sliderMoved), static_cast<MyQAbstractSlider*>(ptr), static_cast<void (MyQAbstractSlider::*)(int)>(&MyQAbstractSlider::Signal_SliderMoved));
}

void QAbstractSlider_SliderMoved(void* ptr, int value)
{
	static_cast<QAbstractSlider*>(ptr)->sliderMoved(value);
}

int QAbstractSlider_SliderPosition(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->sliderPosition();
}

void QAbstractSlider_ConnectSliderPressed(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractSlider*>(ptr), static_cast<void (QAbstractSlider::*)()>(&QAbstractSlider::sliderPressed), static_cast<MyQAbstractSlider*>(ptr), static_cast<void (MyQAbstractSlider::*)()>(&MyQAbstractSlider::Signal_SliderPressed), static_cast<Qt::ConnectionType>(t));
}

void QAbstractSlider_DisconnectSliderPressed(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractSlider*>(ptr), static_cast<void (QAbstractSlider::*)()>(&QAbstractSlider::sliderPressed), static_cast<MyQAbstractSlider*>(ptr), static_cast<void (MyQAbstractSlider::*)()>(&MyQAbstractSlider::Signal_SliderPressed));
}

void QAbstractSlider_SliderPressed(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->sliderPressed();
}

void QAbstractSlider_ConnectSliderReleased(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractSlider*>(ptr), static_cast<void (QAbstractSlider::*)()>(&QAbstractSlider::sliderReleased), static_cast<MyQAbstractSlider*>(ptr), static_cast<void (MyQAbstractSlider::*)()>(&MyQAbstractSlider::Signal_SliderReleased), static_cast<Qt::ConnectionType>(t));
}

void QAbstractSlider_DisconnectSliderReleased(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractSlider*>(ptr), static_cast<void (QAbstractSlider::*)()>(&QAbstractSlider::sliderReleased), static_cast<MyQAbstractSlider*>(ptr), static_cast<void (MyQAbstractSlider::*)()>(&MyQAbstractSlider::Signal_SliderReleased));
}

void QAbstractSlider_SliderReleased(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->sliderReleased();
}

void QAbstractSlider_TriggerAction(void* ptr, long long action)
{
	static_cast<QAbstractSlider*>(ptr)->triggerAction(static_cast<QAbstractSlider::SliderAction>(action));
}

int QAbstractSlider_Value(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->value();
}

void QAbstractSlider_ConnectValueChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractSlider*>(ptr), static_cast<void (QAbstractSlider::*)(int)>(&QAbstractSlider::valueChanged), static_cast<MyQAbstractSlider*>(ptr), static_cast<void (MyQAbstractSlider::*)(int)>(&MyQAbstractSlider::Signal_ValueChanged), static_cast<Qt::ConnectionType>(t));
}

void QAbstractSlider_DisconnectValueChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractSlider*>(ptr), static_cast<void (QAbstractSlider::*)(int)>(&QAbstractSlider::valueChanged), static_cast<MyQAbstractSlider*>(ptr), static_cast<void (MyQAbstractSlider::*)(int)>(&MyQAbstractSlider::Signal_ValueChanged));
}

void QAbstractSlider_ValueChanged(void* ptr, int value)
{
	static_cast<QAbstractSlider*>(ptr)->valueChanged(value);
}

void QAbstractSlider_DestroyQAbstractSlider(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->~QAbstractSlider();
}

void QAbstractSlider_DestroyQAbstractSliderDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQAbstractSpinBox: public QAbstractSpinBox
{
public:
	MyQAbstractSpinBox(QWidget *parent = Q_NULLPTR) : QAbstractSpinBox(parent) {QAbstractSpinBox_QAbstractSpinBox_QRegisterMetaType();};
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	void clear() { callbackQAbstractSpinBox_Clear(this); };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_EditingFinished() { callbackQAbstractSpinBox_EditingFinished(this); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void fixup(QString & input) const { QByteArray* t140f86 = new QByteArray(input.toUtf8()); QtWidgets_PackedString inputPacked = { const_cast<char*>(t140f86->prepend("WHITESPACE").constData()+10), t140f86->size()-10, t140f86 };callbackQAbstractSpinBox_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void selectAll() { callbackQAbstractSpinBox_SelectAll(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void stepBy(int steps) { callbackQAbstractSpinBox_StepBy(this, steps); };
	void stepDown() { callbackQAbstractSpinBox_StepDown(this); };
	QAbstractSpinBox::StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQAbstractSpinBox_StepEnabled(const_cast<void*>(static_cast<const void*>(this)))); };
	void stepUp() { callbackQAbstractSpinBox_StepUp(this); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	QValidator::State validate(QString & input, int & pos) const { QByteArray* t140f86 = new QByteArray(input.toUtf8()); QtWidgets_PackedString inputPacked = { const_cast<char*>(t140f86->prepend("WHITESPACE").constData()+10), t140f86->size()-10, t140f86 };return static_cast<QValidator::State>(callbackQAbstractSpinBox_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	 ~MyQAbstractSpinBox() { callbackQAbstractSpinBox_DestroyQAbstractSpinBox(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QAbstractSpinBox*)
Q_DECLARE_METATYPE(MyQAbstractSpinBox*)

int QAbstractSpinBox_QAbstractSpinBox_QRegisterMetaType(){qRegisterMetaType<QAbstractSpinBox*>(); return qRegisterMetaType<MyQAbstractSpinBox*>();}

void* QAbstractSpinBox_NewQAbstractSpinBox(void* parent)
{
		return new MyQAbstractSpinBox(static_cast<QWidget*>(parent));
}

long long QAbstractSpinBox_Alignment(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->alignment();
}

long long QAbstractSpinBox_ButtonSymbols(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->buttonSymbols();
}

void QAbstractSpinBox_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "clear");
}

void QAbstractSpinBox_ClearDefault(void* ptr)
{
	if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::clear();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::clear();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::clear();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::clear();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::clear();
	} else {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::clear();
	}
}

long long QAbstractSpinBox_CorrectionMode(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->correctionMode();
}

void QAbstractSpinBox_ConnectEditingFinished(void* ptr, long long t)
{
	QObject::connect(static_cast<QAbstractSpinBox*>(ptr), static_cast<void (QAbstractSpinBox::*)()>(&QAbstractSpinBox::editingFinished), static_cast<MyQAbstractSpinBox*>(ptr), static_cast<void (MyQAbstractSpinBox::*)()>(&MyQAbstractSpinBox::Signal_EditingFinished), static_cast<Qt::ConnectionType>(t));
}

void QAbstractSpinBox_DisconnectEditingFinished(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractSpinBox*>(ptr), static_cast<void (QAbstractSpinBox::*)()>(&QAbstractSpinBox::editingFinished), static_cast<MyQAbstractSpinBox*>(ptr), static_cast<void (MyQAbstractSpinBox::*)()>(&MyQAbstractSpinBox::Signal_EditingFinished));
}

void QAbstractSpinBox_EditingFinished(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->editingFinished();
}

void QAbstractSpinBox_Fixup(void* ptr, struct QtWidgets_PackedString input)
{
	static_cast<QAbstractSpinBox*>(ptr)->fixup(*(new QString(QString::fromUtf8(input.data, input.len))));
}

void QAbstractSpinBox_FixupDefault(void* ptr, struct QtWidgets_PackedString input)
{
	if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::fixup(*(new QString(QString::fromUtf8(input.data, input.len))));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::fixup(*(new QString(QString::fromUtf8(input.data, input.len))));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::fixup(*(new QString(QString::fromUtf8(input.data, input.len))));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::fixup(*(new QString(QString::fromUtf8(input.data, input.len))));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::fixup(*(new QString(QString::fromUtf8(input.data, input.len))));
	} else {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::fixup(*(new QString(QString::fromUtf8(input.data, input.len))));
	}
}

char QAbstractSpinBox_HasAcceptableInput(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->hasAcceptableInput();
}

char QAbstractSpinBox_HasFrame(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->hasFrame();
}

void QAbstractSpinBox_InitStyleOption(void* ptr, void* option)
{
	static_cast<QAbstractSpinBox*>(ptr)->initStyleOption(static_cast<QStyleOptionSpinBox*>(option));
}

void QAbstractSpinBox_InterpretText(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->interpretText();
}

char QAbstractSpinBox_IsAccelerated(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->isAccelerated();
}

char QAbstractSpinBox_IsGroupSeparatorShown(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->isGroupSeparatorShown();
}

char QAbstractSpinBox_IsReadOnly(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->isReadOnly();
}

char QAbstractSpinBox_KeyboardTracking(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->keyboardTracking();
}

void* QAbstractSpinBox_LineEdit(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->lineEdit();
}

void QAbstractSpinBox_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "selectAll");
}

void QAbstractSpinBox_SelectAllDefault(void* ptr)
{
	if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::selectAll();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::selectAll();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::selectAll();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::selectAll();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::selectAll();
	} else {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::selectAll();
	}
}

void QAbstractSpinBox_SetAccelerated(void* ptr, char on)
{
	static_cast<QAbstractSpinBox*>(ptr)->setAccelerated(on != 0);
}

void QAbstractSpinBox_SetAlignment(void* ptr, long long flag)
{
	static_cast<QAbstractSpinBox*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(flag));
}

void QAbstractSpinBox_SetButtonSymbols(void* ptr, long long bs)
{
	static_cast<QAbstractSpinBox*>(ptr)->setButtonSymbols(static_cast<QAbstractSpinBox::ButtonSymbols>(bs));
}

void QAbstractSpinBox_SetCorrectionMode(void* ptr, long long cm)
{
	static_cast<QAbstractSpinBox*>(ptr)->setCorrectionMode(static_cast<QAbstractSpinBox::CorrectionMode>(cm));
}

void QAbstractSpinBox_SetFrame(void* ptr, char vbo)
{
	static_cast<QAbstractSpinBox*>(ptr)->setFrame(vbo != 0);
}

void QAbstractSpinBox_SetGroupSeparatorShown(void* ptr, char shown)
{
	static_cast<QAbstractSpinBox*>(ptr)->setGroupSeparatorShown(shown != 0);
}

void QAbstractSpinBox_SetKeyboardTracking(void* ptr, char kt)
{
	static_cast<QAbstractSpinBox*>(ptr)->setKeyboardTracking(kt != 0);
}

void QAbstractSpinBox_SetLineEdit(void* ptr, void* lineEdit)
{
	static_cast<QAbstractSpinBox*>(ptr)->setLineEdit(static_cast<QLineEdit*>(lineEdit));
}

void QAbstractSpinBox_SetReadOnly(void* ptr, char r)
{
	static_cast<QAbstractSpinBox*>(ptr)->setReadOnly(r != 0);
}

void QAbstractSpinBox_SetSpecialValueText(void* ptr, struct QtWidgets_PackedString txt)
{
	static_cast<QAbstractSpinBox*>(ptr)->setSpecialValueText(QString::fromUtf8(txt.data, txt.len));
}

void QAbstractSpinBox_SetWrapping(void* ptr, char w)
{
	static_cast<QAbstractSpinBox*>(ptr)->setWrapping(w != 0);
}

struct QtWidgets_PackedString QAbstractSpinBox_SpecialValueText(void* ptr)
{
	return ({ QByteArray* t81b86a = new QByteArray(static_cast<QAbstractSpinBox*>(ptr)->specialValueText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t81b86a->prepend("WHITESPACE").constData()+10), t81b86a->size()-10, t81b86a }; });
}

void QAbstractSpinBox_StepBy(void* ptr, int steps)
{
	static_cast<QAbstractSpinBox*>(ptr)->stepBy(steps);
}

void QAbstractSpinBox_StepByDefault(void* ptr, int steps)
{
	if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::stepBy(steps);
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::stepBy(steps);
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::stepBy(steps);
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::stepBy(steps);
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::stepBy(steps);
	} else {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::stepBy(steps);
	}
}

void QAbstractSpinBox_StepDown(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "stepDown");
}

void QAbstractSpinBox_StepDownDefault(void* ptr)
{
	if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::stepDown();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::stepDown();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::stepDown();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::stepDown();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::stepDown();
	} else {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::stepDown();
	}
}

long long QAbstractSpinBox_StepEnabled(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->stepEnabled();
}

long long QAbstractSpinBox_StepEnabledDefault(void* ptr)
{
	if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::stepEnabled();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSpinBox*>(ptr)->QSpinBox::stepEnabled();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateEdit*>(ptr)->QDateEdit::stepEnabled();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTimeEdit*>(ptr)->QTimeEdit::stepEnabled();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::stepEnabled();
	} else {
		return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::stepEnabled();
	}
}

void QAbstractSpinBox_StepUp(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "stepUp");
}

void QAbstractSpinBox_StepUpDefault(void* ptr)
{
	if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::stepUp();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::stepUp();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::stepUp();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::stepUp();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::stepUp();
	} else {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::stepUp();
	}
}

struct QtWidgets_PackedString QAbstractSpinBox_Text(void* ptr)
{
	return ({ QByteArray* t58fa9c = new QByteArray(static_cast<QAbstractSpinBox*>(ptr)->text().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t58fa9c->prepend("WHITESPACE").constData()+10), t58fa9c->size()-10, t58fa9c }; });
}

long long QAbstractSpinBox_Validate(void* ptr, struct QtWidgets_PackedString input, int pos)
{
	return static_cast<QAbstractSpinBox*>(ptr)->validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
}

long long QAbstractSpinBox_ValidateDefault(void* ptr, struct QtWidgets_PackedString input, int pos)
{
	if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSpinBox*>(ptr)->QSpinBox::validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateEdit*>(ptr)->QDateEdit::validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTimeEdit*>(ptr)->QTimeEdit::validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
	} else {
		return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
	}
}

char QAbstractSpinBox_Wrapping(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->wrapping();
}

void QAbstractSpinBox_DestroyQAbstractSpinBox(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->~QAbstractSpinBox();
}

void QAbstractSpinBox_DestroyQAbstractSpinBoxDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQAccessibleWidget: public QAccessibleWidget
{
public:
	QStringList actionNames() const { return ({ QtWidgets_PackedString tempVal = callbackQAccessibleWidget_ActionNames(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	QColor backgroundColor() const { return *static_cast<QColor*>(callbackQAccessibleWidget_BackgroundColor(const_cast<void*>(static_cast<const void*>(this)))); };
	QAccessibleInterface * child(int index) const { return static_cast<QAccessibleInterface*>(callbackQAccessibleWidget_Child(const_cast<void*>(static_cast<const void*>(this)), index)); };
	int childCount() const { return callbackQAccessibleWidget_ChildCount(const_cast<void*>(static_cast<const void*>(this))); };
	void doAction(const QString & actionName) { QByteArray* tcd1a8c = new QByteArray(actionName.toUtf8()); QtWidgets_PackedString actionNamePacked = { const_cast<char*>(tcd1a8c->prepend("WHITESPACE").constData()+10), tcd1a8c->size()-10, tcd1a8c };callbackQAccessibleWidget_DoAction(this, actionNamePacked); };
	QAccessibleInterface * focusChild() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleWidget_FocusChild(const_cast<void*>(static_cast<const void*>(this)))); };
	QColor foregroundColor() const { return *static_cast<QColor*>(callbackQAccessibleWidget_ForegroundColor(const_cast<void*>(static_cast<const void*>(this)))); };
	int indexOfChild(const QAccessibleInterface * child) const { return callbackQAccessibleWidget_IndexOfChild(const_cast<void*>(static_cast<const void*>(this)), const_cast<QAccessibleInterface*>(child)); };
	void * interface_cast(QAccessible::InterfaceType t) { return callbackQAccessibleWidget_Interface_cast(this, t); };
	bool isValid() const { return callbackQAccessibleWidget_IsValid(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QStringList keyBindingsForAction(const QString & actionName) const { QByteArray* tcd1a8c = new QByteArray(actionName.toUtf8()); QtWidgets_PackedString actionNamePacked = { const_cast<char*>(tcd1a8c->prepend("WHITESPACE").constData()+10), tcd1a8c->size()-10, tcd1a8c };return ({ QtWidgets_PackedString tempVal = callbackQAccessibleWidget_KeyBindingsForAction(const_cast<void*>(static_cast<const void*>(this)), actionNamePacked); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	QAccessibleInterface * parent() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleWidget_Parent(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect rect() const { return *static_cast<QRect*>(callbackQAccessibleWidget_Rect(const_cast<void*>(static_cast<const void*>(this)))); };
	QAccessible::Role role() const { return static_cast<QAccessible::Role>(callbackQAccessibleWidget_Role(const_cast<void*>(static_cast<const void*>(this)))); };
	QString text(QAccessible::Text t) const { return ({ QtWidgets_PackedString tempVal = callbackQAccessibleWidget_Text(const_cast<void*>(static_cast<const void*>(this)), t); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	QWindow * window() const { return static_cast<QWindow*>(callbackQAccessibleWidget_Window(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQAccessibleWidget() { callbackQAccessibleWidget_DestroyQAccessibleWidget(this); };
	QAccessibleInterface * childAt(int x, int y) const { return static_cast<QAccessibleInterface*>(callbackQAccessibleWidget_ChildAt(const_cast<void*>(static_cast<const void*>(this)), x, y)); };
	QObject * object() const { return static_cast<QObject*>(callbackQAccessibleWidget_Object(const_cast<void*>(static_cast<const void*>(this)))); };
	void setText(QAccessible::Text t, const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQAccessibleWidget_SetText(this, t, textPacked); };
	QString localizedActionDescription(const QString & actionName) const { QByteArray* tcd1a8c = new QByteArray(actionName.toUtf8()); QtWidgets_PackedString actionNamePacked = { const_cast<char*>(tcd1a8c->prepend("WHITESPACE").constData()+10), tcd1a8c->size()-10, tcd1a8c };return ({ QtWidgets_PackedString tempVal = callbackQAccessibleWidget_LocalizedActionDescription(const_cast<void*>(static_cast<const void*>(this)), actionNamePacked); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	QString localizedActionName(const QString & actionName) const { QByteArray* tcd1a8c = new QByteArray(actionName.toUtf8()); QtWidgets_PackedString actionNamePacked = { const_cast<char*>(tcd1a8c->prepend("WHITESPACE").constData()+10), tcd1a8c->size()-10, tcd1a8c };return ({ QtWidgets_PackedString tempVal = callbackQAccessibleWidget_LocalizedActionName(const_cast<void*>(static_cast<const void*>(this)), actionNamePacked); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
};

Q_DECLARE_METATYPE(QAccessibleWidget*)
Q_DECLARE_METATYPE(MyQAccessibleWidget*)

int QAccessibleWidget_QAccessibleWidget_QRegisterMetaType(){qRegisterMetaType<QAccessibleWidget*>(); return qRegisterMetaType<MyQAccessibleWidget*>();}

struct QtWidgets_PackedString QAccessibleWidget_ActionNames(void* ptr)
{
		return ({ QByteArray* t5da01f = new QByteArray(static_cast<QAccessibleWidget*>(ptr)->actionNames().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t5da01f->prepend("WHITESPACE").constData()+10), t5da01f->size()-10, t5da01f }; });
}

struct QtWidgets_PackedString QAccessibleWidget_ActionNamesDefault(void* ptr)
{
		return ({ QByteArray* t1fe7fc = new QByteArray(static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::actionNames().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t1fe7fc->prepend("WHITESPACE").constData()+10), t1fe7fc->size()-10, t1fe7fc }; });
}

void QAccessibleWidget_AddControllingSignal(void* ptr, struct QtWidgets_PackedString sign)
{
		static_cast<QAccessibleWidget*>(ptr)->addControllingSignal(QString::fromUtf8(sign.data, sign.len));
}

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

void* QAccessibleWidget_BackgroundColorDefault(void* ptr)
{
		return new QColor(static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::backgroundColor());
}

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

void* QAccessibleWidget_ChildDefault(void* ptr, int index)
{
		return static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::child(index);
}

int QAccessibleWidget_ChildCount(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->childCount();
}

int QAccessibleWidget_ChildCountDefault(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::childCount();
}

void QAccessibleWidget_DoAction(void* ptr, struct QtWidgets_PackedString actionName)
{
		static_cast<QAccessibleWidget*>(ptr)->doAction(QString::fromUtf8(actionName.data, actionName.len));
}

void QAccessibleWidget_DoActionDefault(void* ptr, struct QtWidgets_PackedString actionName)
{
		static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::doAction(QString::fromUtf8(actionName.data, actionName.len));
}

void* QAccessibleWidget_FocusChild(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->focusChild();
}

void* QAccessibleWidget_FocusChildDefault(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::focusChild();
}

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

void* QAccessibleWidget_ForegroundColorDefault(void* ptr)
{
		return new QColor(static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::foregroundColor());
}

int QAccessibleWidget_IndexOfChild(void* ptr, void* child)
{
	if (dynamic_cast<QAccessibleWidget*>(static_cast<QAccessibleInterface*>(child))) {
		return static_cast<QAccessibleWidget*>(ptr)->indexOfChild(static_cast<QAccessibleWidget*>(child));
	} else {
		return static_cast<QAccessibleWidget*>(ptr)->indexOfChild(static_cast<QAccessibleInterface*>(child));
	}
}

int QAccessibleWidget_IndexOfChildDefault(void* ptr, void* child)
{
	if (dynamic_cast<QAccessibleWidget*>(static_cast<QAccessibleInterface*>(child))) {
		return static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::indexOfChild(static_cast<QAccessibleWidget*>(child));
	} else {
		return static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::indexOfChild(static_cast<QAccessibleInterface*>(child));
	}
}

void* QAccessibleWidget_Interface_cast(void* ptr, long long t)
{
		return static_cast<QAccessibleWidget*>(ptr)->interface_cast(static_cast<QAccessible::InterfaceType>(t));
}

void* QAccessibleWidget_Interface_castDefault(void* ptr, long long t)
{
		return static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::interface_cast(static_cast<QAccessible::InterfaceType>(t));
}

char QAccessibleWidget_IsValid(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->isValid();
}

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

struct QtWidgets_PackedString QAccessibleWidget_KeyBindingsForAction(void* ptr, struct QtWidgets_PackedString actionName)
{
		return ({ QByteArray* tc977a7 = new QByteArray(static_cast<QAccessibleWidget*>(ptr)->keyBindingsForAction(QString::fromUtf8(actionName.data, actionName.len)).join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(tc977a7->prepend("WHITESPACE").constData()+10), tc977a7->size()-10, tc977a7 }; });
}

struct QtWidgets_PackedString QAccessibleWidget_KeyBindingsForActionDefault(void* ptr, struct QtWidgets_PackedString actionName)
{
		return ({ QByteArray* t7d3cdd = new QByteArray(static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::keyBindingsForAction(QString::fromUtf8(actionName.data, actionName.len)).join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t7d3cdd->prepend("WHITESPACE").constData()+10), t7d3cdd->size()-10, t7d3cdd }; });
}

void* QAccessibleWidget_Parent(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->parent();
}

void* QAccessibleWidget_ParentDefault(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::parent();
}

void* QAccessibleWidget_ParentObject(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->parentObject();
}

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

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

long long QAccessibleWidget_Role(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->role();
}

long long QAccessibleWidget_RoleDefault(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::role();
}

struct QtWidgets_PackedString QAccessibleWidget_Text(void* ptr, long long t)
{
		return ({ QByteArray* t7973e3 = new QByteArray(static_cast<QAccessibleWidget*>(ptr)->text(static_cast<QAccessible::Text>(t)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t7973e3->prepend("WHITESPACE").constData()+10), t7973e3->size()-10, t7973e3 }; });
}

struct QtWidgets_PackedString QAccessibleWidget_TextDefault(void* ptr, long long t)
{
		return ({ QByteArray* tb2ef56 = new QByteArray(static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::text(static_cast<QAccessible::Text>(t)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tb2ef56->prepend("WHITESPACE").constData()+10), tb2ef56->size()-10, tb2ef56 }; });
}

void* QAccessibleWidget_Widget(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->widget();
}

void* QAccessibleWidget_Window(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->window();
}

void* QAccessibleWidget_WindowDefault(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::window();
}

void QAccessibleWidget_DestroyQAccessibleWidget(void* ptr)
{
	static_cast<QAccessibleWidget*>(ptr)->~QAccessibleWidget();
}

void QAccessibleWidget_DestroyQAccessibleWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

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

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

void* QAccessibleWidget_Object(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->object();
}

void* QAccessibleWidget_ObjectDefault(void* ptr)
{
		return static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::object();
}

void QAccessibleWidget_SetText(void* ptr, long long t, struct QtWidgets_PackedString text)
{
		static_cast<QAccessibleWidget*>(ptr)->setText(static_cast<QAccessible::Text>(t), QString::fromUtf8(text.data, text.len));
}

void QAccessibleWidget_SetTextDefault(void* ptr, long long t, struct QtWidgets_PackedString text)
{
		static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::setText(static_cast<QAccessible::Text>(t), QString::fromUtf8(text.data, text.len));
}

struct QtWidgets_PackedString QAccessibleWidget_LocalizedActionDescription(void* ptr, struct QtWidgets_PackedString actionName)
{
		return ({ QByteArray* t315e78 = new QByteArray(static_cast<QAccessibleWidget*>(ptr)->localizedActionDescription(QString::fromUtf8(actionName.data, actionName.len)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t315e78->prepend("WHITESPACE").constData()+10), t315e78->size()-10, t315e78 }; });
}

struct QtWidgets_PackedString QAccessibleWidget_LocalizedActionDescriptionDefault(void* ptr, struct QtWidgets_PackedString actionName)
{
		return ({ QByteArray* t7746c1 = new QByteArray(static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::localizedActionDescription(QString::fromUtf8(actionName.data, actionName.len)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t7746c1->prepend("WHITESPACE").constData()+10), t7746c1->size()-10, t7746c1 }; });
}

struct QtWidgets_PackedString QAccessibleWidget_LocalizedActionName(void* ptr, struct QtWidgets_PackedString actionName)
{
		return ({ QByteArray* t535321 = new QByteArray(static_cast<QAccessibleWidget*>(ptr)->localizedActionName(QString::fromUtf8(actionName.data, actionName.len)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t535321->prepend("WHITESPACE").constData()+10), t535321->size()-10, t535321 }; });
}

struct QtWidgets_PackedString QAccessibleWidget_LocalizedActionNameDefault(void* ptr, struct QtWidgets_PackedString actionName)
{
		return ({ QByteArray* teb80ac = new QByteArray(static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::localizedActionName(QString::fromUtf8(actionName.data, actionName.len)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(teb80ac->prepend("WHITESPACE").constData()+10), teb80ac->size()-10, teb80ac }; });
}

class MyQAction: public QAction
{
public:
	MyQAction(QObject *parent = Q_NULLPTR) : QAction(parent) {QAction_QAction_QRegisterMetaType();};
	MyQAction(const QString &text, QObject *parent = Q_NULLPTR) : QAction(text, parent) {QAction_QAction_QRegisterMetaType();};
	MyQAction(const QIcon &icon, const QString &text, QObject *parent = Q_NULLPTR) : QAction(icon, text, parent) {QAction_QAction_QRegisterMetaType();};
	void Signal_Changed() { callbackQAction_Changed(this); };
	bool event(QEvent * e) { return callbackQAction_Event(this, e) != 0; };
	void hover() { callbackQAction_Hover(this); };
	void Signal_Hovered() { callbackQAction_Hovered(this); };
	void setChecked(bool vbo) { callbackQAction_SetChecked(this, vbo); };
	void setDisabled(bool b) { callbackQAction_SetDisabled(this, b); };
	void setEnabled(bool vbo) { callbackQAction_SetEnabled(this, vbo); };
	void setVisible(bool vbo) { callbackQAction_SetVisible(this, vbo); };
	void toggle() { callbackQAction_Toggle(this); };
	void Signal_Toggled(bool checked) { callbackQAction_Toggled(this, checked); };
	void trigger() { callbackQAction_Trigger(this); };
	void Signal_Triggered(bool checked) { callbackQAction_Triggered(this, checked); };
	 ~MyQAction() { callbackQAction_DestroyQAction(this); };
	void childEvent(QChildEvent * event) { callbackQAction_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAction_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAction_CustomEvent(this, event); };
	void deleteLater() { callbackQAction_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAction_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAction_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAction_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAction_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAction_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAction_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QAction*)
Q_DECLARE_METATYPE(MyQAction*)

int QAction_QAction_QRegisterMetaType(){qRegisterMetaType<QAction*>(); return qRegisterMetaType<MyQAction*>();}

void* QAction_NewQAction(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAction(static_cast<QWindow*>(parent));
	} else {
		return new MyQAction(static_cast<QObject*>(parent));
	}
}

void* QAction_NewQAction2(struct QtWidgets_PackedString text, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QWindow*>(parent));
	} else {
		return new MyQAction(QString::fromUtf8(text.data, text.len), static_cast<QObject*>(parent));
	}
}

void* QAction_NewQAction3(void* icon, struct QtWidgets_PackedString text, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QWindow*>(parent));
	} else {
		return new MyQAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QObject*>(parent));
	}
}

void* QAction_ActionGroup(void* ptr)
{
	return static_cast<QAction*>(ptr)->actionGroup();
}

void QAction_Activate(void* ptr, long long event)
{
	static_cast<QAction*>(ptr)->activate(static_cast<QAction::ActionEvent>(event));
}

struct QtWidgets_PackedList QAction_AssociatedGraphicsWidgets(void* ptr)
{
	return ({ QList<QGraphicsWidget *>* tmpValue7c7d2b = new QList<QGraphicsWidget *>(static_cast<QAction*>(ptr)->associatedGraphicsWidgets()); QtWidgets_PackedList { tmpValue7c7d2b, tmpValue7c7d2b->size() }; });
}

struct QtWidgets_PackedList QAction_AssociatedWidgets(void* ptr)
{
	return ({ QList<QWidget *>* tmpValue85cee4 = new QList<QWidget *>(static_cast<QAction*>(ptr)->associatedWidgets()); QtWidgets_PackedList { tmpValue85cee4, tmpValue85cee4->size() }; });
}

char QAction_AutoRepeat(void* ptr)
{
	return static_cast<QAction*>(ptr)->autoRepeat();
}

void QAction_ConnectChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QAction*>(ptr), static_cast<void (QAction::*)()>(&QAction::changed), static_cast<MyQAction*>(ptr), static_cast<void (MyQAction::*)()>(&MyQAction::Signal_Changed), static_cast<Qt::ConnectionType>(t));
}

void QAction_DisconnectChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAction*>(ptr), static_cast<void (QAction::*)()>(&QAction::changed), static_cast<MyQAction*>(ptr), static_cast<void (MyQAction::*)()>(&MyQAction::Signal_Changed));
}

void QAction_Changed(void* ptr)
{
	static_cast<QAction*>(ptr)->changed();
}

void* QAction_Data(void* ptr)
{
	return new QVariant(static_cast<QAction*>(ptr)->data());
}

char QAction_EventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWidgetAction*>(ptr)->QWidgetAction::event(static_cast<QEvent*>(e));
	} else {
		return static_cast<QAction*>(ptr)->QAction::event(static_cast<QEvent*>(e));
	}
}

void* QAction_Font(void* ptr)
{
	return new QFont(static_cast<QAction*>(ptr)->font());
}

void QAction_Hover(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAction*>(ptr), "hover");
}

void QAction_HoverDefault(void* ptr)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::hover();
	} else {
		static_cast<QAction*>(ptr)->QAction::hover();
	}
}

void QAction_ConnectHovered(void* ptr, long long t)
{
	QObject::connect(static_cast<QAction*>(ptr), static_cast<void (QAction::*)()>(&QAction::hovered), static_cast<MyQAction*>(ptr), static_cast<void (MyQAction::*)()>(&MyQAction::Signal_Hovered), static_cast<Qt::ConnectionType>(t));
}

void QAction_DisconnectHovered(void* ptr)
{
	QObject::disconnect(static_cast<QAction*>(ptr), static_cast<void (QAction::*)()>(&QAction::hovered), static_cast<MyQAction*>(ptr), static_cast<void (MyQAction::*)()>(&MyQAction::Signal_Hovered));
}

void QAction_Hovered(void* ptr)
{
	static_cast<QAction*>(ptr)->hovered();
}

void* QAction_Icon(void* ptr)
{
	return new QIcon(static_cast<QAction*>(ptr)->icon());
}

struct QtWidgets_PackedString QAction_IconText(void* ptr)
{
	return ({ QByteArray* t6729e1 = new QByteArray(static_cast<QAction*>(ptr)->iconText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t6729e1->prepend("WHITESPACE").constData()+10), t6729e1->size()-10, t6729e1 }; });
}

char QAction_IsCheckable(void* ptr)
{
	return static_cast<QAction*>(ptr)->isCheckable();
}

char QAction_IsChecked(void* ptr)
{
	return static_cast<QAction*>(ptr)->isChecked();
}

char QAction_IsEnabled(void* ptr)
{
	return static_cast<QAction*>(ptr)->isEnabled();
}

char QAction_IsIconVisibleInMenu(void* ptr)
{
	return static_cast<QAction*>(ptr)->isIconVisibleInMenu();
}

char QAction_IsSeparator(void* ptr)
{
	return static_cast<QAction*>(ptr)->isSeparator();
}

char QAction_IsShortcutVisibleInContextMenu(void* ptr)
{
	return static_cast<QAction*>(ptr)->isShortcutVisibleInContextMenu();
}

char QAction_IsVisible(void* ptr)
{
	return static_cast<QAction*>(ptr)->isVisible();
}

void* QAction_Menu(void* ptr)
{
	return static_cast<QAction*>(ptr)->menu();
}

long long QAction_MenuRole(void* ptr)
{
	return static_cast<QAction*>(ptr)->menuRole();
}

void* QAction_ParentWidget(void* ptr)
{
	return static_cast<QAction*>(ptr)->parentWidget();
}

long long QAction_Priority(void* ptr)
{
	return static_cast<QAction*>(ptr)->priority();
}

void QAction_SetActionGroup(void* ptr, void* group)
{
	static_cast<QAction*>(ptr)->setActionGroup(static_cast<QActionGroup*>(group));
}

void QAction_SetAutoRepeat(void* ptr, char vbo)
{
	static_cast<QAction*>(ptr)->setAutoRepeat(vbo != 0);
}

void QAction_SetCheckable(void* ptr, char vbo)
{
	static_cast<QAction*>(ptr)->setCheckable(vbo != 0);
}

void QAction_SetChecked(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QAction*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}

void QAction_SetCheckedDefault(void* ptr, char vbo)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::setChecked(vbo != 0);
	} else {
		static_cast<QAction*>(ptr)->QAction::setChecked(vbo != 0);
	}
}

void QAction_SetData(void* ptr, void* userData)
{
	static_cast<QAction*>(ptr)->setData(*static_cast<QVariant*>(userData));
}

void QAction_SetDisabled(void* ptr, char b)
{
	QMetaObject::invokeMethod(static_cast<QAction*>(ptr), "setDisabled", Q_ARG(bool, b != 0));
}

void QAction_SetDisabledDefault(void* ptr, char b)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::setDisabled(b != 0);
	} else {
		static_cast<QAction*>(ptr)->QAction::setDisabled(b != 0);
	}
}

void QAction_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QAction*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QAction_SetEnabledDefault(void* ptr, char vbo)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::setEnabled(vbo != 0);
	} else {
		static_cast<QAction*>(ptr)->QAction::setEnabled(vbo != 0);
	}
}

void QAction_SetFont(void* ptr, void* font)
{
	static_cast<QAction*>(ptr)->setFont(*static_cast<QFont*>(font));
}

void QAction_SetIcon(void* ptr, void* icon)
{
	static_cast<QAction*>(ptr)->setIcon(*static_cast<QIcon*>(icon));
}

void QAction_SetIconText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QAction*>(ptr)->setIconText(QString::fromUtf8(text.data, text.len));
}

void QAction_SetIconVisibleInMenu(void* ptr, char visible)
{
	static_cast<QAction*>(ptr)->setIconVisibleInMenu(visible != 0);
}

void QAction_SetMenu(void* ptr, void* menu)
{
	static_cast<QAction*>(ptr)->setMenu(static_cast<QMenu*>(menu));
}

void QAction_SetMenuRole(void* ptr, long long menuRole)
{
	static_cast<QAction*>(ptr)->setMenuRole(static_cast<QAction::MenuRole>(menuRole));
}

void QAction_SetPriority(void* ptr, long long priority)
{
	static_cast<QAction*>(ptr)->setPriority(static_cast<QAction::Priority>(priority));
}

void QAction_SetSeparator(void* ptr, char b)
{
	static_cast<QAction*>(ptr)->setSeparator(b != 0);
}

void QAction_SetShortcut(void* ptr, void* shortcut)
{
	static_cast<QAction*>(ptr)->setShortcut(*static_cast<QKeySequence*>(shortcut));
}

void QAction_SetShortcutContext(void* ptr, long long context)
{
	static_cast<QAction*>(ptr)->setShortcutContext(static_cast<Qt::ShortcutContext>(context));
}

void QAction_SetShortcutVisibleInContextMenu(void* ptr, char show)
{
	static_cast<QAction*>(ptr)->setShortcutVisibleInContextMenu(show != 0);
}

void QAction_SetShortcuts(void* ptr, void* shortcuts)
{
	static_cast<QAction*>(ptr)->setShortcuts(*static_cast<QList<QKeySequence>*>(shortcuts));
}

void QAction_SetShortcuts2(void* ptr, long long key)
{
	static_cast<QAction*>(ptr)->setShortcuts(static_cast<QKeySequence::StandardKey>(key));
}

void QAction_SetStatusTip(void* ptr, struct QtWidgets_PackedString statusTip)
{
	static_cast<QAction*>(ptr)->setStatusTip(QString::fromUtf8(statusTip.data, statusTip.len));
}

void QAction_SetText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QAction*>(ptr)->setText(QString::fromUtf8(text.data, text.len));
}

void QAction_SetToolTip(void* ptr, struct QtWidgets_PackedString tip)
{
	static_cast<QAction*>(ptr)->setToolTip(QString::fromUtf8(tip.data, tip.len));
}

void QAction_SetVisible(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QAction*>(ptr), "setVisible", Q_ARG(bool, vbo != 0));
}

void QAction_SetVisibleDefault(void* ptr, char vbo)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::setVisible(vbo != 0);
	} else {
		static_cast<QAction*>(ptr)->QAction::setVisible(vbo != 0);
	}
}

void QAction_SetWhatsThis(void* ptr, struct QtWidgets_PackedString what)
{
	static_cast<QAction*>(ptr)->setWhatsThis(QString::fromUtf8(what.data, what.len));
}

void* QAction_Shortcut(void* ptr)
{
	return new QKeySequence(static_cast<QAction*>(ptr)->shortcut());
}

long long QAction_ShortcutContext(void* ptr)
{
	return static_cast<QAction*>(ptr)->shortcutContext();
}

struct QtWidgets_PackedList QAction_Shortcuts(void* ptr)
{
	return ({ QList<QKeySequence>* tmpValue30197e = new QList<QKeySequence>(static_cast<QAction*>(ptr)->shortcuts()); QtWidgets_PackedList { tmpValue30197e, tmpValue30197e->size() }; });
}

char QAction_ShowStatusText(void* ptr, void* widget)
{
		return static_cast<QAction*>(ptr)->showStatusText(static_cast<QWidget*>(widget));
}

struct QtWidgets_PackedString QAction_StatusTip(void* ptr)
{
	return ({ QByteArray* t5e64a4 = new QByteArray(static_cast<QAction*>(ptr)->statusTip().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t5e64a4->prepend("WHITESPACE").constData()+10), t5e64a4->size()-10, t5e64a4 }; });
}

struct QtWidgets_PackedString QAction_Text(void* ptr)
{
	return ({ QByteArray* t0f57fa = new QByteArray(static_cast<QAction*>(ptr)->text().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t0f57fa->prepend("WHITESPACE").constData()+10), t0f57fa->size()-10, t0f57fa }; });
}

void QAction_Toggle(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAction*>(ptr), "toggle");
}

void QAction_ToggleDefault(void* ptr)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::toggle();
	} else {
		static_cast<QAction*>(ptr)->QAction::toggle();
	}
}

void QAction_ConnectToggled(void* ptr, long long t)
{
	QObject::connect(static_cast<QAction*>(ptr), static_cast<void (QAction::*)(bool)>(&QAction::toggled), static_cast<MyQAction*>(ptr), static_cast<void (MyQAction::*)(bool)>(&MyQAction::Signal_Toggled), static_cast<Qt::ConnectionType>(t));
}

void QAction_DisconnectToggled(void* ptr)
{
	QObject::disconnect(static_cast<QAction*>(ptr), static_cast<void (QAction::*)(bool)>(&QAction::toggled), static_cast<MyQAction*>(ptr), static_cast<void (MyQAction::*)(bool)>(&MyQAction::Signal_Toggled));
}

void QAction_Toggled(void* ptr, char checked)
{
	static_cast<QAction*>(ptr)->toggled(checked != 0);
}

struct QtWidgets_PackedString QAction_ToolTip(void* ptr)
{
	return ({ QByteArray* td308d4 = new QByteArray(static_cast<QAction*>(ptr)->toolTip().toUtf8()); QtWidgets_PackedString { const_cast<char*>(td308d4->prepend("WHITESPACE").constData()+10), td308d4->size()-10, td308d4 }; });
}

void QAction_Trigger(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAction*>(ptr), "trigger");
}

void QAction_TriggerDefault(void* ptr)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::trigger();
	} else {
		static_cast<QAction*>(ptr)->QAction::trigger();
	}
}

void QAction_ConnectTriggered(void* ptr, long long t)
{
	QObject::connect(static_cast<QAction*>(ptr), static_cast<void (QAction::*)(bool)>(&QAction::triggered), static_cast<MyQAction*>(ptr), static_cast<void (MyQAction::*)(bool)>(&MyQAction::Signal_Triggered), static_cast<Qt::ConnectionType>(t));
}

void QAction_DisconnectTriggered(void* ptr)
{
	QObject::disconnect(static_cast<QAction*>(ptr), static_cast<void (QAction::*)(bool)>(&QAction::triggered), static_cast<MyQAction*>(ptr), static_cast<void (MyQAction::*)(bool)>(&MyQAction::Signal_Triggered));
}

void QAction_Triggered(void* ptr, char checked)
{
	static_cast<QAction*>(ptr)->triggered(checked != 0);
}

struct QtWidgets_PackedString QAction_WhatsThis(void* ptr)
{
	return ({ QByteArray* tba6af8 = new QByteArray(static_cast<QAction*>(ptr)->whatsThis().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tba6af8->prepend("WHITESPACE").constData()+10), tba6af8->size()-10, tba6af8 }; });
}

void QAction_DestroyQAction(void* ptr)
{
	static_cast<QAction*>(ptr)->~QAction();
}

void QAction_DestroyQActionDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QAction___associatedGraphicsWidgets_atList(void* ptr, int i)
{
	return ({QGraphicsWidget * tmp = static_cast<QList<QGraphicsWidget *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsWidget *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsWidget *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QAction___associatedGraphicsWidgets_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsWidget *>();
}

void* QAction___associatedWidgets_atList(void* ptr, int i)
{
	return ({QWidget * tmp = static_cast<QList<QWidget *>*>(ptr)->at(i); if (i == static_cast<QList<QWidget *>*>(ptr)->size()-1) { static_cast<QList<QWidget *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QAction___associatedWidgets_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QWidget *>();
}

void* QAction___setShortcuts_shortcuts_atList(void* ptr, int i)
{
	return new QKeySequence(({QKeySequence tmp = static_cast<QList<QKeySequence>*>(ptr)->at(i); if (i == static_cast<QList<QKeySequence>*>(ptr)->size()-1) { static_cast<QList<QKeySequence>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QAction___setShortcuts_shortcuts_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QKeySequence>();
}

void* QAction___shortcuts_atList(void* ptr, int i)
{
	return new QKeySequence(({QKeySequence tmp = static_cast<QList<QKeySequence>*>(ptr)->at(i); if (i == static_cast<QList<QKeySequence>*>(ptr)->size()-1) { static_cast<QList<QKeySequence>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QAction___shortcuts_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QKeySequence>();
}

void* QAction___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAction___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QAction___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QAction___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAction___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QAction___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QAction___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void QAction_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QAction*>(ptr)->QAction::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QAction_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QAction*>(ptr)->QAction::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QAction_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QAction*>(ptr)->QAction::customEvent(static_cast<QEvent*>(event));
	}
}

void QAction_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::deleteLater();
	} else {
		static_cast<QAction*>(ptr)->QAction::deleteLater();
	}
}

void QAction_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QAction*>(ptr)->QAction::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

char QAction_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QWidgetAction*>(ptr)->QWidgetAction::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QWidgetAction*>(ptr)->QWidgetAction::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QWidgetAction*>(ptr)->QWidgetAction::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QWidgetAction*>(ptr)->QWidgetAction::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QWidgetAction*>(ptr)->QWidgetAction::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QAction*>(ptr)->QAction::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAction*>(ptr)->QAction::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QAction*>(ptr)->QAction::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAction*>(ptr)->QAction::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAction*>(ptr)->QAction::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void* QAction_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QWidgetAction*>(ptr)->QWidgetAction::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QAction*>(ptr)->QAction::metaObject());
	}
}

void QAction_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWidgetAction*>(static_cast<QObject*>(ptr))) {
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QAction*>(ptr)->QAction::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

class MyQActionGroup: public QActionGroup
{
public:
	MyQActionGroup(QObject *parent) : QActionGroup(parent) {QActionGroup_QActionGroup_QRegisterMetaType();};
	void Signal_Hovered(QAction * action) { callbackQActionGroup_Hovered(this, action); };
	void setDisabled(bool b) { callbackQActionGroup_SetDisabled(this, b); };
	void setEnabled(bool vbo) { callbackQActionGroup_SetEnabled(this, vbo); };
	void setExclusive(bool vbo) { callbackQActionGroup_SetExclusive(this, vbo); };
	void setVisible(bool vbo) { callbackQActionGroup_SetVisible(this, vbo); };
	void Signal_Triggered(QAction * action) { callbackQActionGroup_Triggered(this, action); };
	 ~MyQActionGroup() { callbackQActionGroup_DestroyQActionGroup(this); };
	void childEvent(QChildEvent * event) { callbackQActionGroup_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQActionGroup_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQActionGroup_CustomEvent(this, event); };
	void deleteLater() { callbackQActionGroup_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQActionGroup_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQActionGroup_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQActionGroup_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQActionGroup_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQActionGroup_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQActionGroup_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQActionGroup_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QActionGroup*)
Q_DECLARE_METATYPE(MyQActionGroup*)

int QActionGroup_QActionGroup_QRegisterMetaType(){qRegisterMetaType<QActionGroup*>(); return qRegisterMetaType<MyQActionGroup*>();}

void* QActionGroup_NewQActionGroup(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQActionGroup(static_cast<QWindow*>(parent));
	} else {
		return new MyQActionGroup(static_cast<QObject*>(parent));
	}
}

struct QtWidgets_PackedList QActionGroup_Actions(void* ptr)
{
	return ({ QList<QAction *>* tmpValue766e2b = new QList<QAction *>(static_cast<QActionGroup*>(ptr)->actions()); QtWidgets_PackedList { tmpValue766e2b, tmpValue766e2b->size() }; });
}

void* QActionGroup_AddAction(void* ptr, void* action)
{
	return static_cast<QActionGroup*>(ptr)->addAction(static_cast<QAction*>(action));
}

void* QActionGroup_AddAction2(void* ptr, struct QtWidgets_PackedString text)
{
	return static_cast<QActionGroup*>(ptr)->addAction(QString::fromUtf8(text.data, text.len));
}

void* QActionGroup_AddAction3(void* ptr, void* icon, struct QtWidgets_PackedString text)
{
	return static_cast<QActionGroup*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len));
}

void* QActionGroup_CheckedAction(void* ptr)
{
	return static_cast<QActionGroup*>(ptr)->checkedAction();
}

void QActionGroup_ConnectHovered(void* ptr, long long t)
{
	QObject::connect(static_cast<QActionGroup*>(ptr), static_cast<void (QActionGroup::*)(QAction *)>(&QActionGroup::hovered), static_cast<MyQActionGroup*>(ptr), static_cast<void (MyQActionGroup::*)(QAction *)>(&MyQActionGroup::Signal_Hovered), static_cast<Qt::ConnectionType>(t));
}

void QActionGroup_DisconnectHovered(void* ptr)
{
	QObject::disconnect(static_cast<QActionGroup*>(ptr), static_cast<void (QActionGroup::*)(QAction *)>(&QActionGroup::hovered), static_cast<MyQActionGroup*>(ptr), static_cast<void (MyQActionGroup::*)(QAction *)>(&MyQActionGroup::Signal_Hovered));
}

void QActionGroup_Hovered(void* ptr, void* action)
{
	static_cast<QActionGroup*>(ptr)->hovered(static_cast<QAction*>(action));
}

char QActionGroup_IsEnabled(void* ptr)
{
	return static_cast<QActionGroup*>(ptr)->isEnabled();
}

char QActionGroup_IsExclusive(void* ptr)
{
	return static_cast<QActionGroup*>(ptr)->isExclusive();
}

char QActionGroup_IsVisible(void* ptr)
{
	return static_cast<QActionGroup*>(ptr)->isVisible();
}

void QActionGroup_RemoveAction(void* ptr, void* action)
{
	static_cast<QActionGroup*>(ptr)->removeAction(static_cast<QAction*>(action));
}

void QActionGroup_SetDisabled(void* ptr, char b)
{
	QMetaObject::invokeMethod(static_cast<QActionGroup*>(ptr), "setDisabled", Q_ARG(bool, b != 0));
}

void QActionGroup_SetDisabledDefault(void* ptr, char b)
{
		static_cast<QActionGroup*>(ptr)->QActionGroup::setDisabled(b != 0);
}

void QActionGroup_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QActionGroup*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QActionGroup_SetEnabledDefault(void* ptr, char vbo)
{
		static_cast<QActionGroup*>(ptr)->QActionGroup::setEnabled(vbo != 0);
}

void QActionGroup_SetExclusive(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QActionGroup*>(ptr), "setExclusive", Q_ARG(bool, vbo != 0));
}

void QActionGroup_SetExclusiveDefault(void* ptr, char vbo)
{
		static_cast<QActionGroup*>(ptr)->QActionGroup::setExclusive(vbo != 0);
}

void QActionGroup_SetVisible(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QActionGroup*>(ptr), "setVisible", Q_ARG(bool, vbo != 0));
}

void QActionGroup_SetVisibleDefault(void* ptr, char vbo)
{
		static_cast<QActionGroup*>(ptr)->QActionGroup::setVisible(vbo != 0);
}

void QActionGroup_ConnectTriggered(void* ptr, long long t)
{
	QObject::connect(static_cast<QActionGroup*>(ptr), static_cast<void (QActionGroup::*)(QAction *)>(&QActionGroup::triggered), static_cast<MyQActionGroup*>(ptr), static_cast<void (MyQActionGroup::*)(QAction *)>(&MyQActionGroup::Signal_Triggered), static_cast<Qt::ConnectionType>(t));
}

void QActionGroup_DisconnectTriggered(void* ptr)
{
	QObject::disconnect(static_cast<QActionGroup*>(ptr), static_cast<void (QActionGroup::*)(QAction *)>(&QActionGroup::triggered), static_cast<MyQActionGroup*>(ptr), static_cast<void (MyQActionGroup::*)(QAction *)>(&MyQActionGroup::Signal_Triggered));
}

void QActionGroup_Triggered(void* ptr, void* action)
{
	static_cast<QActionGroup*>(ptr)->triggered(static_cast<QAction*>(action));
}

void QActionGroup_DestroyQActionGroup(void* ptr)
{
	static_cast<QActionGroup*>(ptr)->~QActionGroup();
}

void QActionGroup_DestroyQActionGroupDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QActionGroup___actions_atList(void* ptr, int i)
{
	return ({QAction * tmp = static_cast<QList<QAction *>*>(ptr)->at(i); if (i == static_cast<QList<QAction *>*>(ptr)->size()-1) { static_cast<QList<QAction *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QActionGroup___actions_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAction *>();
}

void* QActionGroup___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QActionGroup___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QActionGroup___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QActionGroup___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QActionGroup___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QActionGroup___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QActionGroup___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

void QActionGroup_DeleteLaterDefault(void* ptr)
{
		static_cast<QActionGroup*>(ptr)->QActionGroup::deleteLater();
}

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

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

char QActionGroup_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QActionGroup*>(ptr)->QActionGroup::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QActionGroup*>(ptr)->QActionGroup::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QActionGroup*>(ptr)->QActionGroup::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QActionGroup*>(ptr)->QActionGroup::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QActionGroup*>(ptr)->QActionGroup::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQApplication: public QApplication
{
public:
	MyQApplication(int &argc, char **argv) : QApplication(argc, argv) {QApplication_QApplication_QRegisterMetaType();};
	void aboutQt() { callbackQApplication_AboutQt(this); };
	bool autoSipEnabled() const { return callbackQApplication_AutoSipEnabled(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void closeAllWindows() { callbackQApplication_CloseAllWindows(this); };
	bool event(QEvent * e) { return callbackQApplication_Event(this, e) != 0; };
	void Signal_FocusChanged(QWidget * old, QWidget * now) { callbackQApplication_FocusChanged(this, old, now); };
	void setAutoSipEnabled(const bool enabled) { callbackQApplication_SetAutoSipEnabled(this, enabled); };
	void setStyleSheet(const QString & sheet) { QByteArray* t542ebc = new QByteArray(sheet.toUtf8()); QtWidgets_PackedString sheetPacked = { const_cast<char*>(t542ebc->prepend("WHITESPACE").constData()+10), t542ebc->size()-10, t542ebc };callbackQApplication_SetStyleSheet(this, sheetPacked); };
	 ~MyQApplication() { callbackQApplication_DestroyQApplication(this); };
	void Signal_ApplicationDisplayNameChanged() { callbackQApplication_ApplicationDisplayNameChanged(this); };
	void Signal_ApplicationStateChanged(Qt::ApplicationState state) { callbackQApplication_ApplicationStateChanged(this, state); };
	void Signal_CommitDataRequest(QSessionManager & manager) { callbackQApplication_CommitDataRequest(this, static_cast<QSessionManager*>(&manager)); };
	void Signal_FocusObjectChanged(QObject * focusObject) { callbackQApplication_FocusObjectChanged(this, focusObject); };
	void Signal_FocusWindowChanged(QWindow * focusWindow) { callbackQApplication_FocusWindowChanged(this, focusWindow); };
	void Signal_FontChanged(const QFont & font) { callbackQApplication_FontChanged(this, const_cast<QFont*>(&font)); };
	void Signal_FontDatabaseChanged() { callbackQApplication_FontDatabaseChanged(this); };
	void Signal_LastWindowClosed() { callbackQApplication_LastWindowClosed(this); };
	void Signal_LayoutDirectionChanged(Qt::LayoutDirection direction) { callbackQApplication_LayoutDirectionChanged(this, direction); };
	void Signal_PaletteChanged(const QPalette & palette) { callbackQApplication_PaletteChanged(this, const_cast<QPalette*>(&palette)); };
	void Signal_PrimaryScreenChanged(QScreen * screen) { callbackQApplication_PrimaryScreenChanged(this, screen); };
	void Signal_SaveStateRequest(QSessionManager & manager) { callbackQApplication_SaveStateRequest(this, static_cast<QSessionManager*>(&manager)); };
	void Signal_ScreenAdded(QScreen * screen) { callbackQApplication_ScreenAdded(this, screen); };
	void Signal_ScreenRemoved(QScreen * screen) { callbackQApplication_ScreenRemoved(this, screen); };
	void Signal_AboutToQuit() { callbackQApplication_AboutToQuit(this); };
	void Signal_ApplicationNameChanged() { callbackQApplication_ApplicationNameChanged(this); };
	void Signal_ApplicationVersionChanged() { callbackQApplication_ApplicationVersionChanged(this); };
	void Signal_OrganizationDomainChanged() { callbackQApplication_OrganizationDomainChanged(this); };
	void Signal_OrganizationNameChanged() { callbackQApplication_OrganizationNameChanged(this); };
	void quit() { callbackQApplication_Quit(this); };
	void childEvent(QChildEvent * event) { callbackQApplication_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQApplication_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQApplication_CustomEvent(this, event); };
	void deleteLater() { callbackQApplication_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQApplication_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQApplication_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQApplication_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQApplication_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQApplication_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQApplication_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QApplication*)
Q_DECLARE_METATYPE(MyQApplication*)

int QApplication_QApplication_QRegisterMetaType(){qRegisterMetaType<QApplication*>(); return qRegisterMetaType<MyQApplication*>();}

void* QApplication_NewQApplication(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 MyQApplication(argcs, argvs);
}

void QApplication_AboutQt(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QApplication*>(ptr), "aboutQt");
}

void QApplication_AboutQtDefault(void* ptr)
{
		static_cast<QApplication*>(ptr)->QApplication::aboutQt();
}

void* QApplication_QApplication_ActiveModalWidget()
{
	return QApplication::activeModalWidget();
}

void* QApplication_QApplication_ActivePopupWidget()
{
	return QApplication::activePopupWidget();
}

void* QApplication_QApplication_ActiveWindow()
{
	return QApplication::activeWindow();
}

void QApplication_QApplication_Alert(void* widget, int msec)
{
		QApplication::alert(static_cast<QWidget*>(widget), msec);
}

struct QtWidgets_PackedList QApplication_QApplication_AllWidgets()
{
	return ({ QList<QWidget *>* tmpValue15db35 = new QList<QWidget *>(QApplication::allWidgets()); QtWidgets_PackedList { tmpValue15db35, tmpValue15db35->size() }; });
}

char QApplication_AutoSipEnabled(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QApplication*>(ptr), "autoSipEnabled", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QApplication_AutoSipEnabledDefault(void* ptr)
{
		return static_cast<QApplication*>(ptr)->QApplication::autoSipEnabled();
}

void QApplication_QApplication_Beep()
{
	QApplication::beep();
}

void QApplication_CloseAllWindows(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QApplication*>(ptr), "closeAllWindows");
}

void QApplication_CloseAllWindowsDefault(void* ptr)
{
		static_cast<QApplication*>(ptr)->QApplication::closeAllWindows();
}

int QApplication_QApplication_CursorFlashTime()
{
	return QApplication::cursorFlashTime();
}

void* QApplication_QApplication_Desktop()
{
	return QApplication::desktop();
}

int QApplication_QApplication_DoubleClickInterval()
{
	return QApplication::doubleClickInterval();
}

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

int QApplication_QApplication_Exec()
{
	return QApplication::exec();
}

void QApplication_ConnectFocusChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QApplication*>(ptr), static_cast<void (QApplication::*)(QWidget *, QWidget *)>(&QApplication::focusChanged), static_cast<MyQApplication*>(ptr), static_cast<void (MyQApplication::*)(QWidget *, QWidget *)>(&MyQApplication::Signal_FocusChanged), static_cast<Qt::ConnectionType>(t));
}

void QApplication_DisconnectFocusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QApplication*>(ptr), static_cast<void (QApplication::*)(QWidget *, QWidget *)>(&QApplication::focusChanged), static_cast<MyQApplication*>(ptr), static_cast<void (MyQApplication::*)(QWidget *, QWidget *)>(&MyQApplication::Signal_FocusChanged));
}

void QApplication_FocusChanged(void* ptr, void* old, void* now)
{
		static_cast<QApplication*>(ptr)->focusChanged(static_cast<QWidget*>(old), static_cast<QWidget*>(now));
}

void* QApplication_QApplication_FocusWidget()
{
	return QApplication::focusWidget();
}

void* QApplication_QApplication_Font()
{
	return new QFont(QApplication::font());
}

void* QApplication_QApplication_Font2(void* widget)
{
		return new QFont(QApplication::font(static_cast<QWidget*>(widget)));
}

void* QApplication_QApplication_Font3(char* className)
{
	return new QFont(QApplication::font(const_cast<const char*>(className)));
}

void* QApplication_QApplication_FontMetrics()
{
	return new QFontMetrics(QApplication::fontMetrics());
}

void* QApplication_QApplication_GlobalStrut()
{
	return ({ QSize tmpValue = QApplication::globalStrut(); new QSize(tmpValue.width(), tmpValue.height()); });
}

char QApplication_QApplication_IsEffectEnabled(long long effect)
{
	return QApplication::isEffectEnabled(static_cast<Qt::UIEffect>(effect));
}

int QApplication_QApplication_KeyboardInputInterval()
{
	return QApplication::keyboardInputInterval();
}

long long QApplication_QApplication_NavigationMode()
{
#ifdef QT_KEYPAD_NAVIGATION
	return QApplication::navigationMode();
#else
	return 0;
#endif
}

void* QApplication_QApplication_Palette(void* widget)
{
		return new QPalette(QApplication::palette(static_cast<QWidget*>(widget)));
}

void* QApplication_QApplication_Palette2(char* className)
{
	return new QPalette(QApplication::palette(const_cast<const char*>(className)));
}

void QApplication_QApplication_SetActiveWindow(void* active)
{
		QApplication::setActiveWindow(static_cast<QWidget*>(active));
}

void QApplication_SetAutoSipEnabled(void* ptr, char enabled)
{
	QMetaObject::invokeMethod(static_cast<QApplication*>(ptr), "setAutoSipEnabled", Q_ARG(const bool, enabled != 0));
}

void QApplication_SetAutoSipEnabledDefault(void* ptr, char enabled)
{
		static_cast<QApplication*>(ptr)->QApplication::setAutoSipEnabled(enabled != 0);
}

void QApplication_QApplication_SetCursorFlashTime(int vin)
{
	QApplication::setCursorFlashTime(vin);
}

void QApplication_QApplication_SetDoubleClickInterval(int vin)
{
	QApplication::setDoubleClickInterval(vin);
}

void QApplication_QApplication_SetEffectEnabled(long long effect, char enable)
{
	QApplication::setEffectEnabled(static_cast<Qt::UIEffect>(effect), enable != 0);
}

void QApplication_QApplication_SetFont(void* font, char* className)
{
	QApplication::setFont(*static_cast<QFont*>(font), const_cast<const char*>(className));
}

void QApplication_QApplication_SetGlobalStrut(void* vqs)
{
	QApplication::setGlobalStrut(*static_cast<QSize*>(vqs));
}

void QApplication_QApplication_SetKeyboardInputInterval(int vin)
{
	QApplication::setKeyboardInputInterval(vin);
}

void QApplication_QApplication_SetNavigationMode(long long mode)
{
#ifdef QT_KEYPAD_NAVIGATION
	QApplication::setNavigationMode(static_cast<Qt::NavigationMode>(mode));
#endif
}

void QApplication_QApplication_SetPalette(void* palette, char* className)
{
	QApplication::setPalette(*static_cast<QPalette*>(palette), const_cast<const char*>(className));
}

void QApplication_QApplication_SetStartDragDistance(int l)
{
	QApplication::setStartDragDistance(l);
}

void QApplication_QApplication_SetStartDragTime(int ms)
{
	QApplication::setStartDragTime(ms);
}

void QApplication_QApplication_SetStyle(void* style)
{
	QApplication::setStyle(static_cast<QStyle*>(style));
}

void* QApplication_QApplication_SetStyle2(struct QtWidgets_PackedString style)
{
	return QApplication::setStyle(QString::fromUtf8(style.data, style.len));
}

void QApplication_SetStyleSheet(void* ptr, struct QtWidgets_PackedString sheet)
{
	QMetaObject::invokeMethod(static_cast<QApplication*>(ptr), "setStyleSheet", Q_ARG(const QString, QString::fromUtf8(sheet.data, sheet.len)));
}

void QApplication_SetStyleSheetDefault(void* ptr, struct QtWidgets_PackedString sheet)
{
		static_cast<QApplication*>(ptr)->QApplication::setStyleSheet(QString::fromUtf8(sheet.data, sheet.len));
}

void QApplication_QApplication_SetWheelScrollLines(int vin)
{
	QApplication::setWheelScrollLines(vin);
}

void QApplication_QApplication_SetWindowIcon(void* icon)
{
	QApplication::setWindowIcon(*static_cast<QIcon*>(icon));
}

int QApplication_QApplication_StartDragDistance()
{
	return QApplication::startDragDistance();
}

int QApplication_QApplication_StartDragTime()
{
	return QApplication::startDragTime();
}

void* QApplication_QApplication_Style()
{
	return QApplication::style();
}

struct QtWidgets_PackedString QApplication_StyleSheet(void* ptr)
{
	return ({ QByteArray* ta53b66 = new QByteArray(static_cast<QApplication*>(ptr)->styleSheet().toUtf8()); QtWidgets_PackedString { const_cast<char*>(ta53b66->prepend("WHITESPACE").constData()+10), ta53b66->size()-10, ta53b66 }; });
}

void* QApplication_QApplication_TopLevelAt(void* point)
{
	return QApplication::topLevelAt(*static_cast<QPoint*>(point));
}

void* QApplication_QApplication_TopLevelAt2(int x, int y)
{
	return QApplication::topLevelAt(x, y);
}

struct QtWidgets_PackedList QApplication_QApplication_TopLevelWidgets()
{
	return ({ QList<QWidget *>* tmpValue8ff1e1 = new QList<QWidget *>(QApplication::topLevelWidgets()); QtWidgets_PackedList { tmpValue8ff1e1, tmpValue8ff1e1->size() }; });
}

int QApplication_QApplication_WheelScrollLines()
{
	return QApplication::wheelScrollLines();
}

void* QApplication_QApplication_WidgetAt(void* point)
{
	return QApplication::widgetAt(*static_cast<QPoint*>(point));
}

void* QApplication_QApplication_WidgetAt2(int x, int y)
{
	return QApplication::widgetAt(x, y);
}

void* QApplication_QApplication_WindowIcon()
{
	return new QIcon(QApplication::windowIcon());
}

void QApplication_DestroyQApplication(void* ptr)
{
	static_cast<QApplication*>(ptr)->~QApplication();
}

void QApplication_DestroyQApplicationDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QApplication___allWidgets_atList(void* ptr, int i)
{
	return ({QWidget * tmp = static_cast<QList<QWidget *>*>(ptr)->at(i); if (i == static_cast<QList<QWidget *>*>(ptr)->size()-1) { static_cast<QList<QWidget *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QApplication___allWidgets_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QWidget *>();
}

void* QApplication___topLevelWidgets_atList(void* ptr, int i)
{
	return ({QWidget * tmp = static_cast<QList<QWidget *>*>(ptr)->at(i); if (i == static_cast<QList<QWidget *>*>(ptr)->size()-1) { static_cast<QList<QWidget *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QApplication___topLevelWidgets_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QWidget *>();
}

void* QApplication___screens_atList(void* ptr, int i)
{
	return ({QScreen * tmp = static_cast<QList<QScreen *>*>(ptr)->at(i); if (i == static_cast<QList<QScreen *>*>(ptr)->size()-1) { static_cast<QList<QScreen *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QApplication___screens_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QScreen *>();
}

void* QApplication___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QApplication___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QApplication___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QApplication___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QApplication___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QApplication___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QApplication___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void QApplication_QuitDefault(void* ptr)
{
		static_cast<QApplication*>(ptr)->QApplication::quit();
}

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

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

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

void QApplication_DeleteLaterDefault(void* ptr)
{
		static_cast<QApplication*>(ptr)->QApplication::deleteLater();
}

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

char QApplication_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QApplication*>(ptr)->QApplication::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QApplication*>(ptr)->QApplication::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QApplication*>(ptr)->QApplication::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QApplication*>(ptr)->QApplication::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QApplication*>(ptr)->QApplication::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQBoxLayout: public QBoxLayout
{
public:
	MyQBoxLayout(QBoxLayout::Direction dir, QWidget *parent = Q_NULLPTR) : QBoxLayout(dir, parent) {QBoxLayout_QBoxLayout_QRegisterMetaType();};
	void addItem(QLayoutItem * item) { callbackQBoxLayout_AddItem(this, item); };
	int count() const { return callbackQBoxLayout_Count(const_cast<void*>(static_cast<const void*>(this))); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQLayout_ExpandingDirections(const_cast<void*>(static_cast<const void*>(this)))); };
	bool hasHeightForWidth() const { return callbackQLayoutItem_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQLayoutItem_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void invalidate() { callbackQLayoutItem_Invalidate(this); };
	QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQBoxLayout_ItemAt(const_cast<void*>(static_cast<const void*>(this)), index)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQLayout_MaximumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	int minimumHeightForWidth(int w) const { return callbackQLayoutItem_MinimumHeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQLayout_MinimumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	void setGeometry(const QRect & r) { callbackQLayout_SetGeometry(this, const_cast<QRect*>(&r)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQBoxLayout_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQBoxLayout_TakeAt(this, index)); };
	 ~MyQBoxLayout() { callbackQBoxLayout_DestroyQBoxLayout(this); };
	void childEvent(QChildEvent * e) { callbackQLayout_ChildEvent(this, e); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayoutItem_ControlTypes(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQLayout_Geometry(const_cast<void*>(static_cast<const void*>(this)))); };
	int indexOf(QWidget * widget) const { return callbackQLayout_IndexOf(const_cast<void*>(static_cast<const void*>(this)), widget); };
	bool isEmpty() const { return callbackQLayout_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QLayout * layout() { return static_cast<QLayout*>(callbackQLayoutItem_Layout(this)); };
	void connectNotify(const QMetaMethod & sign) { callbackQLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQLayout_CustomEvent(this, event); };
	void deleteLater() { callbackQLayout_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQLayout_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQLayout_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQLayout_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLayout_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQLayout_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQLayout_TimerEvent(this, event); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayoutItem_SpacerItem(this)); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQLayoutItem_Widget(this)); };
};

Q_DECLARE_METATYPE(QBoxLayout*)
Q_DECLARE_METATYPE(MyQBoxLayout*)

int QBoxLayout_QBoxLayout_QRegisterMetaType(){qRegisterMetaType<QBoxLayout*>(); return qRegisterMetaType<MyQBoxLayout*>();}

void* QBoxLayout_NewQBoxLayout(long long dir, void* parent)
{
		return new MyQBoxLayout(static_cast<QBoxLayout::Direction>(dir), static_cast<QWidget*>(parent));
}

void QBoxLayout_AddItem(void* ptr, void* item)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
		static_cast<QBoxLayout*>(ptr)->addItem(static_cast<QLayout*>(item));
	} else {
		static_cast<QBoxLayout*>(ptr)->addItem(static_cast<QLayoutItem*>(item));
	}
}

void QBoxLayout_AddItemDefault(void* ptr, void* item)
{
	if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
			static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::addItem(static_cast<QLayout*>(item));
		} else {
			static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::addItem(static_cast<QLayoutItem*>(item));
		}
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
			static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::addItem(static_cast<QLayout*>(item));
		} else {
			static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::addItem(static_cast<QLayoutItem*>(item));
		}
	} else {
		if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
			static_cast<QBoxLayout*>(ptr)->QBoxLayout::addItem(static_cast<QLayout*>(item));
		} else {
			static_cast<QBoxLayout*>(ptr)->QBoxLayout::addItem(static_cast<QLayoutItem*>(item));
		}
	}
}

void QBoxLayout_AddLayout(void* ptr, void* layout, int stretch)
{
		static_cast<QBoxLayout*>(ptr)->addLayout(static_cast<QLayout*>(layout), stretch);
}

void QBoxLayout_AddSpacerItem(void* ptr, void* spacerItem)
{
	static_cast<QBoxLayout*>(ptr)->addSpacerItem(static_cast<QSpacerItem*>(spacerItem));
}

void QBoxLayout_AddSpacing(void* ptr, int size)
{
	static_cast<QBoxLayout*>(ptr)->addSpacing(size);
}

void QBoxLayout_AddStretch(void* ptr, int stretch)
{
	static_cast<QBoxLayout*>(ptr)->addStretch(stretch);
}

void QBoxLayout_AddStrut(void* ptr, int size)
{
	static_cast<QBoxLayout*>(ptr)->addStrut(size);
}

void QBoxLayout_AddWidget(void* ptr, void* widget, int stretch, long long alignment)
{
		static_cast<QBoxLayout*>(ptr)->addWidget(static_cast<QWidget*>(widget), stretch, static_cast<Qt::AlignmentFlag>(alignment));
}

int QBoxLayout_Count(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->count();
}

int QBoxLayout_CountDefault(void* ptr)
{
	if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::count();
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::count();
	} else {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::count();
	}
}

long long QBoxLayout_Direction(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->direction();
}

void QBoxLayout_InsertItem(void* ptr, int index, void* item)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
		static_cast<QBoxLayout*>(ptr)->insertItem(index, static_cast<QLayout*>(item));
	} else {
		static_cast<QBoxLayout*>(ptr)->insertItem(index, static_cast<QLayoutItem*>(item));
	}
}

void QBoxLayout_InsertLayout(void* ptr, int index, void* layout, int stretch)
{
		static_cast<QBoxLayout*>(ptr)->insertLayout(index, static_cast<QLayout*>(layout), stretch);
}

void QBoxLayout_InsertSpacerItem(void* ptr, int index, void* spacerItem)
{
	static_cast<QBoxLayout*>(ptr)->insertSpacerItem(index, static_cast<QSpacerItem*>(spacerItem));
}

void QBoxLayout_InsertSpacing(void* ptr, int index, int size)
{
	static_cast<QBoxLayout*>(ptr)->insertSpacing(index, size);
}

void QBoxLayout_InsertStretch(void* ptr, int index, int stretch)
{
	static_cast<QBoxLayout*>(ptr)->insertStretch(index, stretch);
}

void QBoxLayout_InsertWidget(void* ptr, int index, void* widget, int stretch, long long alignment)
{
		static_cast<QBoxLayout*>(ptr)->insertWidget(index, static_cast<QWidget*>(widget), stretch, static_cast<Qt::AlignmentFlag>(alignment));
}

void* QBoxLayout_ItemAt(void* ptr, int index)
{
	return static_cast<QBoxLayout*>(ptr)->itemAt(index);
}

void* QBoxLayout_ItemAtDefault(void* ptr, int index)
{
	if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::itemAt(index);
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::itemAt(index);
	} else {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::itemAt(index);
	}
}

void QBoxLayout_SetDirection(void* ptr, long long direction)
{
	static_cast<QBoxLayout*>(ptr)->setDirection(static_cast<QBoxLayout::Direction>(direction));
}

void QBoxLayout_SetStretch(void* ptr, int index, int stretch)
{
	static_cast<QBoxLayout*>(ptr)->setStretch(index, stretch);
}

char QBoxLayout_SetStretchFactor(void* ptr, void* widget, int stretch)
{
		return static_cast<QBoxLayout*>(ptr)->setStretchFactor(static_cast<QWidget*>(widget), stretch);
}

char QBoxLayout_SetStretchFactor2(void* ptr, void* layout, int stretch)
{
		return static_cast<QBoxLayout*>(ptr)->setStretchFactor(static_cast<QLayout*>(layout), stretch);
}

void* QBoxLayout_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QBoxLayout*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QBoxLayout_SizeHintDefault(void* ptr)
{
	if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QBoxLayout*>(ptr)->QBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

int QBoxLayout_Stretch(void* ptr, int index)
{
	return static_cast<QBoxLayout*>(ptr)->stretch(index);
}

void* QBoxLayout_TakeAt(void* ptr, int index)
{
	return static_cast<QBoxLayout*>(ptr)->takeAt(index);
}

void* QBoxLayout_TakeAtDefault(void* ptr, int index)
{
	if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::takeAt(index);
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::takeAt(index);
	} else {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::takeAt(index);
	}
}

void QBoxLayout_DestroyQBoxLayout(void* ptr)
{
	static_cast<QBoxLayout*>(ptr)->~QBoxLayout();
}

void QBoxLayout_DestroyQBoxLayoutDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQButtonGroup: public QButtonGroup
{
public:
	MyQButtonGroup(QObject *parent = Q_NULLPTR) : QButtonGroup(parent) {QButtonGroup_QButtonGroup_QRegisterMetaType();};
	void Signal_ButtonClicked(QAbstractButton * button) { callbackQButtonGroup_ButtonClicked(this, button); };
	void Signal_ButtonClicked2(int id) { callbackQButtonGroup_ButtonClicked2(this, id); };
	void Signal_ButtonPressed(QAbstractButton * button) { callbackQButtonGroup_ButtonPressed(this, button); };
	void Signal_ButtonPressed2(int id) { callbackQButtonGroup_ButtonPressed2(this, id); };
	void Signal_ButtonReleased(QAbstractButton * button) { callbackQButtonGroup_ButtonReleased(this, button); };
	void Signal_ButtonReleased2(int id) { callbackQButtonGroup_ButtonReleased2(this, id); };
	void Signal_ButtonToggled(QAbstractButton * button, bool checked) { callbackQButtonGroup_ButtonToggled(this, button, checked); };
	void Signal_ButtonToggled2(int id, bool checked) { callbackQButtonGroup_ButtonToggled2(this, id, checked); };
	 ~MyQButtonGroup() { callbackQButtonGroup_DestroyQButtonGroup(this); };
	void childEvent(QChildEvent * event) { callbackQButtonGroup_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQButtonGroup_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQButtonGroup_CustomEvent(this, event); };
	void deleteLater() { callbackQButtonGroup_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQButtonGroup_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQButtonGroup_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQButtonGroup_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQButtonGroup_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQButtonGroup_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQButtonGroup_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQButtonGroup_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QButtonGroup*)
Q_DECLARE_METATYPE(MyQButtonGroup*)

int QButtonGroup_QButtonGroup_QRegisterMetaType(){qRegisterMetaType<QButtonGroup*>(); return qRegisterMetaType<MyQButtonGroup*>();}

void* QButtonGroup_NewQButtonGroup(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQButtonGroup(static_cast<QWindow*>(parent));
	} else {
		return new MyQButtonGroup(static_cast<QObject*>(parent));
	}
}

void QButtonGroup_AddButton(void* ptr, void* button, int id)
{
	static_cast<QButtonGroup*>(ptr)->addButton(static_cast<QAbstractButton*>(button), id);
}

void* QButtonGroup_Button(void* ptr, int id)
{
	return static_cast<QButtonGroup*>(ptr)->button(id);
}

void QButtonGroup_ConnectButtonClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(QAbstractButton *)>(&QButtonGroup::buttonClicked), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(QAbstractButton *)>(&MyQButtonGroup::Signal_ButtonClicked), static_cast<Qt::ConnectionType>(t));
}

void QButtonGroup_DisconnectButtonClicked(void* ptr)
{
	QObject::disconnect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(QAbstractButton *)>(&QButtonGroup::buttonClicked), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(QAbstractButton *)>(&MyQButtonGroup::Signal_ButtonClicked));
}

void QButtonGroup_ButtonClicked(void* ptr, void* button)
{
	static_cast<QButtonGroup*>(ptr)->buttonClicked(static_cast<QAbstractButton*>(button));
}

void QButtonGroup_ConnectButtonClicked2(void* ptr, long long t)
{
	QObject::connect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(int)>(&QButtonGroup::buttonClicked), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(int)>(&MyQButtonGroup::Signal_ButtonClicked2), static_cast<Qt::ConnectionType>(t));
}

void QButtonGroup_DisconnectButtonClicked2(void* ptr)
{
	QObject::disconnect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(int)>(&QButtonGroup::buttonClicked), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(int)>(&MyQButtonGroup::Signal_ButtonClicked2));
}

void QButtonGroup_ButtonClicked2(void* ptr, int id)
{
	static_cast<QButtonGroup*>(ptr)->buttonClicked(id);
}

void QButtonGroup_ConnectButtonPressed(void* ptr, long long t)
{
	QObject::connect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(QAbstractButton *)>(&QButtonGroup::buttonPressed), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(QAbstractButton *)>(&MyQButtonGroup::Signal_ButtonPressed), static_cast<Qt::ConnectionType>(t));
}

void QButtonGroup_DisconnectButtonPressed(void* ptr)
{
	QObject::disconnect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(QAbstractButton *)>(&QButtonGroup::buttonPressed), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(QAbstractButton *)>(&MyQButtonGroup::Signal_ButtonPressed));
}

void QButtonGroup_ButtonPressed(void* ptr, void* button)
{
	static_cast<QButtonGroup*>(ptr)->buttonPressed(static_cast<QAbstractButton*>(button));
}

void QButtonGroup_ConnectButtonPressed2(void* ptr, long long t)
{
	QObject::connect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(int)>(&QButtonGroup::buttonPressed), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(int)>(&MyQButtonGroup::Signal_ButtonPressed2), static_cast<Qt::ConnectionType>(t));
}

void QButtonGroup_DisconnectButtonPressed2(void* ptr)
{
	QObject::disconnect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(int)>(&QButtonGroup::buttonPressed), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(int)>(&MyQButtonGroup::Signal_ButtonPressed2));
}

void QButtonGroup_ButtonPressed2(void* ptr, int id)
{
	static_cast<QButtonGroup*>(ptr)->buttonPressed(id);
}

void QButtonGroup_ConnectButtonReleased(void* ptr, long long t)
{
	QObject::connect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(QAbstractButton *)>(&QButtonGroup::buttonReleased), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(QAbstractButton *)>(&MyQButtonGroup::Signal_ButtonReleased), static_cast<Qt::ConnectionType>(t));
}

void QButtonGroup_DisconnectButtonReleased(void* ptr)
{
	QObject::disconnect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(QAbstractButton *)>(&QButtonGroup::buttonReleased), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(QAbstractButton *)>(&MyQButtonGroup::Signal_ButtonReleased));
}

void QButtonGroup_ButtonReleased(void* ptr, void* button)
{
	static_cast<QButtonGroup*>(ptr)->buttonReleased(static_cast<QAbstractButton*>(button));
}

void QButtonGroup_ConnectButtonReleased2(void* ptr, long long t)
{
	QObject::connect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(int)>(&QButtonGroup::buttonReleased), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(int)>(&MyQButtonGroup::Signal_ButtonReleased2), static_cast<Qt::ConnectionType>(t));
}

void QButtonGroup_DisconnectButtonReleased2(void* ptr)
{
	QObject::disconnect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(int)>(&QButtonGroup::buttonReleased), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(int)>(&MyQButtonGroup::Signal_ButtonReleased2));
}

void QButtonGroup_ButtonReleased2(void* ptr, int id)
{
	static_cast<QButtonGroup*>(ptr)->buttonReleased(id);
}

void QButtonGroup_ConnectButtonToggled(void* ptr, long long t)
{
	QObject::connect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(QAbstractButton *, bool)>(&QButtonGroup::buttonToggled), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(QAbstractButton *, bool)>(&MyQButtonGroup::Signal_ButtonToggled), static_cast<Qt::ConnectionType>(t));
}

void QButtonGroup_DisconnectButtonToggled(void* ptr)
{
	QObject::disconnect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(QAbstractButton *, bool)>(&QButtonGroup::buttonToggled), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(QAbstractButton *, bool)>(&MyQButtonGroup::Signal_ButtonToggled));
}

void QButtonGroup_ButtonToggled(void* ptr, void* button, char checked)
{
	static_cast<QButtonGroup*>(ptr)->buttonToggled(static_cast<QAbstractButton*>(button), checked != 0);
}

void QButtonGroup_ConnectButtonToggled2(void* ptr, long long t)
{
	QObject::connect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(int, bool)>(&QButtonGroup::buttonToggled), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(int, bool)>(&MyQButtonGroup::Signal_ButtonToggled2), static_cast<Qt::ConnectionType>(t));
}

void QButtonGroup_DisconnectButtonToggled2(void* ptr)
{
	QObject::disconnect(static_cast<QButtonGroup*>(ptr), static_cast<void (QButtonGroup::*)(int, bool)>(&QButtonGroup::buttonToggled), static_cast<MyQButtonGroup*>(ptr), static_cast<void (MyQButtonGroup::*)(int, bool)>(&MyQButtonGroup::Signal_ButtonToggled2));
}

void QButtonGroup_ButtonToggled2(void* ptr, int id, char checked)
{
	static_cast<QButtonGroup*>(ptr)->buttonToggled(id, checked != 0);
}

struct QtWidgets_PackedList QButtonGroup_Buttons(void* ptr)
{
	return ({ QList<QAbstractButton *>* tmpValuea4306e = new QList<QAbstractButton *>(static_cast<QButtonGroup*>(ptr)->buttons()); QtWidgets_PackedList { tmpValuea4306e, tmpValuea4306e->size() }; });
}

void* QButtonGroup_CheckedButton(void* ptr)
{
	return static_cast<QButtonGroup*>(ptr)->checkedButton();
}

int QButtonGroup_CheckedId(void* ptr)
{
	return static_cast<QButtonGroup*>(ptr)->checkedId();
}

char QButtonGroup_Exclusive(void* ptr)
{
	return static_cast<QButtonGroup*>(ptr)->exclusive();
}

int QButtonGroup_Id(void* ptr, void* button)
{
	return static_cast<QButtonGroup*>(ptr)->id(static_cast<QAbstractButton*>(button));
}

void QButtonGroup_RemoveButton(void* ptr, void* button)
{
	static_cast<QButtonGroup*>(ptr)->removeButton(static_cast<QAbstractButton*>(button));
}

void QButtonGroup_SetExclusive(void* ptr, char vbo)
{
	static_cast<QButtonGroup*>(ptr)->setExclusive(vbo != 0);
}

void QButtonGroup_SetId(void* ptr, void* button, int id)
{
	static_cast<QButtonGroup*>(ptr)->setId(static_cast<QAbstractButton*>(button), id);
}

void QButtonGroup_DestroyQButtonGroup(void* ptr)
{
	static_cast<QButtonGroup*>(ptr)->~QButtonGroup();
}

void QButtonGroup_DestroyQButtonGroupDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QButtonGroup___buttons_atList(void* ptr, int i)
{
	return ({QAbstractButton * tmp = static_cast<QList<QAbstractButton *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractButton *>*>(ptr)->size()-1) { static_cast<QList<QAbstractButton *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QButtonGroup___buttons_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAbstractButton *>();
}

void* QButtonGroup___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QButtonGroup___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QButtonGroup___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QButtonGroup___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QButtonGroup___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QButtonGroup___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QButtonGroup___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

void QButtonGroup_DeleteLaterDefault(void* ptr)
{
		static_cast<QButtonGroup*>(ptr)->QButtonGroup::deleteLater();
}

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

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

char QButtonGroup_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QButtonGroup*>(ptr)->QButtonGroup::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QButtonGroup*>(ptr)->QButtonGroup::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QButtonGroup*>(ptr)->QButtonGroup::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QButtonGroup*>(ptr)->QButtonGroup::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QButtonGroup*>(ptr)->QButtonGroup::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQCalendarWidget: public QCalendarWidget
{
public:
	MyQCalendarWidget(QWidget *parent = Q_NULLPTR) : QCalendarWidget(parent) {QCalendarWidget_QCalendarWidget_QRegisterMetaType();};
	void Signal_Activated(const QDate & date) { callbackQCalendarWidget_Activated(this, const_cast<QDate*>(&date)); };
	void Signal_Clicked(const QDate & date) { callbackQCalendarWidget_Clicked(this, const_cast<QDate*>(&date)); };
	void Signal_CurrentPageChanged(int year, int month) { callbackQCalendarWidget_CurrentPageChanged(this, year, month); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void paintCell(QPainter * painter, const QRect & rect, const QDate & date) const { callbackQCalendarWidget_PaintCell(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QRect*>(&rect), const_cast<QDate*>(&date)); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void Signal_SelectionChanged() { callbackQCalendarWidget_SelectionChanged(this); };
	void setCurrentPage(int year, int month) { callbackQCalendarWidget_SetCurrentPage(this, year, month); };
	void setDateRange(const QDate & min, const QDate & max) { callbackQCalendarWidget_SetDateRange(this, const_cast<QDate*>(&min), const_cast<QDate*>(&max)); };
	void setGridVisible(bool show) { callbackQCalendarWidget_SetGridVisible(this, show); };
	void setNavigationBarVisible(bool visible) { callbackQCalendarWidget_SetNavigationBarVisible(this, visible); };
	void setSelectedDate(const QDate & date) { callbackQCalendarWidget_SetSelectedDate(this, const_cast<QDate*>(&date)); };
	void showNextMonth() { callbackQCalendarWidget_ShowNextMonth(this); };
	void showNextYear() { callbackQCalendarWidget_ShowNextYear(this); };
	void showPreviousMonth() { callbackQCalendarWidget_ShowPreviousMonth(this); };
	void showPreviousYear() { callbackQCalendarWidget_ShowPreviousYear(this); };
	void showSelectedDate() { callbackQCalendarWidget_ShowSelectedDate(this); };
	void showToday() { callbackQCalendarWidget_ShowToday(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQCalendarWidget() { callbackQCalendarWidget_DestroyQCalendarWidget(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCalendarWidget*)
Q_DECLARE_METATYPE(MyQCalendarWidget*)

int QCalendarWidget_QCalendarWidget_QRegisterMetaType(){qRegisterMetaType<QCalendarWidget*>(); return qRegisterMetaType<MyQCalendarWidget*>();}

void* QCalendarWidget_NewQCalendarWidget(void* parent)
{
		return new MyQCalendarWidget(static_cast<QWidget*>(parent));
}

void QCalendarWidget_ConnectActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QCalendarWidget*>(ptr), static_cast<void (QCalendarWidget::*)(const QDate &)>(&QCalendarWidget::activated), static_cast<MyQCalendarWidget*>(ptr), static_cast<void (MyQCalendarWidget::*)(const QDate &)>(&MyQCalendarWidget::Signal_Activated), static_cast<Qt::ConnectionType>(t));
}

void QCalendarWidget_DisconnectActivated(void* ptr)
{
	QObject::disconnect(static_cast<QCalendarWidget*>(ptr), static_cast<void (QCalendarWidget::*)(const QDate &)>(&QCalendarWidget::activated), static_cast<MyQCalendarWidget*>(ptr), static_cast<void (MyQCalendarWidget::*)(const QDate &)>(&MyQCalendarWidget::Signal_Activated));
}

void QCalendarWidget_Activated(void* ptr, void* date)
{
	static_cast<QCalendarWidget*>(ptr)->activated(*static_cast<QDate*>(date));
}

void QCalendarWidget_ConnectClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QCalendarWidget*>(ptr), static_cast<void (QCalendarWidget::*)(const QDate &)>(&QCalendarWidget::clicked), static_cast<MyQCalendarWidget*>(ptr), static_cast<void (MyQCalendarWidget::*)(const QDate &)>(&MyQCalendarWidget::Signal_Clicked), static_cast<Qt::ConnectionType>(t));
}

void QCalendarWidget_DisconnectClicked(void* ptr)
{
	QObject::disconnect(static_cast<QCalendarWidget*>(ptr), static_cast<void (QCalendarWidget::*)(const QDate &)>(&QCalendarWidget::clicked), static_cast<MyQCalendarWidget*>(ptr), static_cast<void (MyQCalendarWidget::*)(const QDate &)>(&MyQCalendarWidget::Signal_Clicked));
}

void QCalendarWidget_Clicked(void* ptr, void* date)
{
	static_cast<QCalendarWidget*>(ptr)->clicked(*static_cast<QDate*>(date));
}

void QCalendarWidget_ConnectCurrentPageChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCalendarWidget*>(ptr), static_cast<void (QCalendarWidget::*)(int, int)>(&QCalendarWidget::currentPageChanged), static_cast<MyQCalendarWidget*>(ptr), static_cast<void (MyQCalendarWidget::*)(int, int)>(&MyQCalendarWidget::Signal_CurrentPageChanged), static_cast<Qt::ConnectionType>(t));
}

void QCalendarWidget_DisconnectCurrentPageChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCalendarWidget*>(ptr), static_cast<void (QCalendarWidget::*)(int, int)>(&QCalendarWidget::currentPageChanged), static_cast<MyQCalendarWidget*>(ptr), static_cast<void (MyQCalendarWidget::*)(int, int)>(&MyQCalendarWidget::Signal_CurrentPageChanged));
}

void QCalendarWidget_CurrentPageChanged(void* ptr, int year, int month)
{
	static_cast<QCalendarWidget*>(ptr)->currentPageChanged(year, month);
}

int QCalendarWidget_DateEditAcceptDelay(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->dateEditAcceptDelay();
}

struct QtWidgets_PackedList QCalendarWidget_DateTextFormat(void* ptr)
{
	return ({ QMap<QDate, QTextCharFormat>* tmpValue83ea0b = new QMap<QDate, QTextCharFormat>(static_cast<QCalendarWidget*>(ptr)->dateTextFormat()); QtWidgets_PackedList { tmpValue83ea0b, tmpValue83ea0b->size() }; });
}

void* QCalendarWidget_DateTextFormat2(void* ptr, void* date)
{
	return new QTextCharFormat(static_cast<QCalendarWidget*>(ptr)->dateTextFormat(*static_cast<QDate*>(date)));
}

long long QCalendarWidget_FirstDayOfWeek(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->firstDayOfWeek();
}

void* QCalendarWidget_HeaderTextFormat(void* ptr)
{
	return new QTextCharFormat(static_cast<QCalendarWidget*>(ptr)->headerTextFormat());
}

long long QCalendarWidget_HorizontalHeaderFormat(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->horizontalHeaderFormat();
}

char QCalendarWidget_IsDateEditEnabled(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->isDateEditEnabled();
}

char QCalendarWidget_IsGridVisible(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->isGridVisible();
}

char QCalendarWidget_IsNavigationBarVisible(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->isNavigationBarVisible();
}

void* QCalendarWidget_MaximumDate(void* ptr)
{
	return new QDate(static_cast<QCalendarWidget*>(ptr)->maximumDate());
}

void* QCalendarWidget_MinimumDate(void* ptr)
{
	return new QDate(static_cast<QCalendarWidget*>(ptr)->minimumDate());
}

int QCalendarWidget_MonthShown(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->monthShown();
}

void QCalendarWidget_PaintCell(void* ptr, void* painter, void* rect, void* date)
{
	static_cast<QCalendarWidget*>(ptr)->paintCell(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), *static_cast<QDate*>(date));
}

void QCalendarWidget_PaintCellDefault(void* ptr, void* painter, void* rect, void* date)
{
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::paintCell(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), *static_cast<QDate*>(date));
}

void* QCalendarWidget_SelectedDate(void* ptr)
{
	return new QDate(static_cast<QCalendarWidget*>(ptr)->selectedDate());
}

void QCalendarWidget_ConnectSelectionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCalendarWidget*>(ptr), static_cast<void (QCalendarWidget::*)()>(&QCalendarWidget::selectionChanged), static_cast<MyQCalendarWidget*>(ptr), static_cast<void (MyQCalendarWidget::*)()>(&MyQCalendarWidget::Signal_SelectionChanged), static_cast<Qt::ConnectionType>(t));
}

void QCalendarWidget_DisconnectSelectionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCalendarWidget*>(ptr), static_cast<void (QCalendarWidget::*)()>(&QCalendarWidget::selectionChanged), static_cast<MyQCalendarWidget*>(ptr), static_cast<void (MyQCalendarWidget::*)()>(&MyQCalendarWidget::Signal_SelectionChanged));
}

void QCalendarWidget_SelectionChanged(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->selectionChanged();
}

long long QCalendarWidget_SelectionMode(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->selectionMode();
}

void QCalendarWidget_SetCurrentPage(void* ptr, int year, int month)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setCurrentPage", Q_ARG(int, year), Q_ARG(int, month));
}

void QCalendarWidget_SetCurrentPageDefault(void* ptr, int year, int month)
{
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setCurrentPage(year, month);
}

void QCalendarWidget_SetDateEditAcceptDelay(void* ptr, int delay)
{
	static_cast<QCalendarWidget*>(ptr)->setDateEditAcceptDelay(delay);
}

void QCalendarWidget_SetDateEditEnabled(void* ptr, char enable)
{
	static_cast<QCalendarWidget*>(ptr)->setDateEditEnabled(enable != 0);
}

void QCalendarWidget_SetDateRange(void* ptr, void* min, void* max)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setDateRange", Q_ARG(const QDate, *static_cast<QDate*>(min)), Q_ARG(const QDate, *static_cast<QDate*>(max)));
}

void QCalendarWidget_SetDateRangeDefault(void* ptr, void* min, void* max)
{
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setDateRange(*static_cast<QDate*>(min), *static_cast<QDate*>(max));
}

void QCalendarWidget_SetDateTextFormat(void* ptr, void* date, void* format)
{
	static_cast<QCalendarWidget*>(ptr)->setDateTextFormat(*static_cast<QDate*>(date), *static_cast<QTextCharFormat*>(format));
}

void QCalendarWidget_SetFirstDayOfWeek(void* ptr, long long dayOfWeek)
{
	static_cast<QCalendarWidget*>(ptr)->setFirstDayOfWeek(static_cast<Qt::DayOfWeek>(dayOfWeek));
}

void QCalendarWidget_SetGridVisible(void* ptr, char show)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setGridVisible", Q_ARG(bool, show != 0));
}

void QCalendarWidget_SetGridVisibleDefault(void* ptr, char show)
{
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setGridVisible(show != 0);
}

void QCalendarWidget_SetHeaderTextFormat(void* ptr, void* format)
{
	static_cast<QCalendarWidget*>(ptr)->setHeaderTextFormat(*static_cast<QTextCharFormat*>(format));
}

void QCalendarWidget_SetHorizontalHeaderFormat(void* ptr, long long format)
{
	static_cast<QCalendarWidget*>(ptr)->setHorizontalHeaderFormat(static_cast<QCalendarWidget::HorizontalHeaderFormat>(format));
}

void QCalendarWidget_SetMaximumDate(void* ptr, void* date)
{
	static_cast<QCalendarWidget*>(ptr)->setMaximumDate(*static_cast<QDate*>(date));
}

void QCalendarWidget_SetMinimumDate(void* ptr, void* date)
{
	static_cast<QCalendarWidget*>(ptr)->setMinimumDate(*static_cast<QDate*>(date));
}

void QCalendarWidget_SetNavigationBarVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setNavigationBarVisible", Q_ARG(bool, visible != 0));
}

void QCalendarWidget_SetNavigationBarVisibleDefault(void* ptr, char visible)
{
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setNavigationBarVisible(visible != 0);
}

void QCalendarWidget_SetSelectedDate(void* ptr, void* date)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setSelectedDate", Q_ARG(const QDate, *static_cast<QDate*>(date)));
}

void QCalendarWidget_SetSelectedDateDefault(void* ptr, void* date)
{
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setSelectedDate(*static_cast<QDate*>(date));
}

void QCalendarWidget_SetSelectionMode(void* ptr, long long mode)
{
	static_cast<QCalendarWidget*>(ptr)->setSelectionMode(static_cast<QCalendarWidget::SelectionMode>(mode));
}

void QCalendarWidget_SetVerticalHeaderFormat(void* ptr, long long format)
{
	static_cast<QCalendarWidget*>(ptr)->setVerticalHeaderFormat(static_cast<QCalendarWidget::VerticalHeaderFormat>(format));
}

void QCalendarWidget_SetWeekdayTextFormat(void* ptr, long long dayOfWeek, void* format)
{
	static_cast<QCalendarWidget*>(ptr)->setWeekdayTextFormat(static_cast<Qt::DayOfWeek>(dayOfWeek), *static_cast<QTextCharFormat*>(format));
}

void QCalendarWidget_ShowNextMonth(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showNextMonth");
}

void QCalendarWidget_ShowNextMonthDefault(void* ptr)
{
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showNextMonth();
}

void QCalendarWidget_ShowNextYear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showNextYear");
}

void QCalendarWidget_ShowNextYearDefault(void* ptr)
{
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showNextYear();
}

void QCalendarWidget_ShowPreviousMonth(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showPreviousMonth");
}

void QCalendarWidget_ShowPreviousMonthDefault(void* ptr)
{
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showPreviousMonth();
}

void QCalendarWidget_ShowPreviousYear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showPreviousYear");
}

void QCalendarWidget_ShowPreviousYearDefault(void* ptr)
{
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showPreviousYear();
}

void QCalendarWidget_ShowSelectedDate(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showSelectedDate");
}

void QCalendarWidget_ShowSelectedDateDefault(void* ptr)
{
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showSelectedDate();
}

void QCalendarWidget_ShowToday(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showToday");
}

void QCalendarWidget_ShowTodayDefault(void* ptr)
{
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showToday();
}

void QCalendarWidget_UpdateCell(void* ptr, void* date)
{
	static_cast<QCalendarWidget*>(ptr)->updateCell(*static_cast<QDate*>(date));
}

void QCalendarWidget_UpdateCells(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->updateCells();
}

long long QCalendarWidget_VerticalHeaderFormat(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->verticalHeaderFormat();
}

void* QCalendarWidget_WeekdayTextFormat(void* ptr, long long dayOfWeek)
{
	return new QTextCharFormat(static_cast<QCalendarWidget*>(ptr)->weekdayTextFormat(static_cast<Qt::DayOfWeek>(dayOfWeek)));
}

int QCalendarWidget_YearShown(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->yearShown();
}

void QCalendarWidget_DestroyQCalendarWidget(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->~QCalendarWidget();
}

void QCalendarWidget_DestroyQCalendarWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QCalendarWidget___dateTextFormat_atList(void* ptr, void* v, int i)
{
	return new QTextCharFormat(({ QTextCharFormat tmp = static_cast<QMap<QDate, QTextCharFormat>*>(ptr)->value(*static_cast<QDate*>(v)); if (i == static_cast<QMap<QDate, QTextCharFormat>*>(ptr)->size()-1) { static_cast<QMap<QDate, QTextCharFormat>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QCalendarWidget___dateTextFormat_setList(void* ptr, void* key, void* i)
{
	static_cast<QMap<QDate, QTextCharFormat>*>(ptr)->insert(*static_cast<QDate*>(key), *static_cast<QTextCharFormat*>(i));
}

void* QCalendarWidget___dateTextFormat_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<QDate, QTextCharFormat>();
}

struct QtWidgets_PackedList QCalendarWidget___dateTextFormat_keyList(void* ptr)
{
	return ({ QList<QDate>* tmpValueb38b32 = new QList<QDate>(static_cast<QMap<QDate, QTextCharFormat>*>(ptr)->keys()); QtWidgets_PackedList { tmpValueb38b32, tmpValueb38b32->size() }; });
}

void* QCalendarWidget_____dateTextFormat_keyList_atList(void* ptr, int i)
{
	return new QDate(({QDate tmp = static_cast<QList<QDate>*>(ptr)->at(i); if (i == static_cast<QList<QDate>*>(ptr)->size()-1) { static_cast<QList<QDate>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QCalendarWidget_____dateTextFormat_keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QDate>();
}

class MyQCheckBox: public QCheckBox
{
public:
	MyQCheckBox(QWidget *parent = Q_NULLPTR) : QCheckBox(parent) {QCheckBox_QCheckBox_QRegisterMetaType();};
	MyQCheckBox(const QString &text, QWidget *parent = Q_NULLPTR) : QCheckBox(text, parent) {QCheckBox_QCheckBox_QRegisterMetaType();};
	void checkStateSet() { callbackQAbstractButton_CheckStateSet(this); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	bool hitButton(const QPoint & pos) const { return callbackQAbstractButton_HitButton(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&pos)) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void nextCheckState() { callbackQAbstractButton_NextCheckState(this); };
	void paintEvent(QPaintEvent * vqp) { callbackQCheckBox_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_StateChanged(int state) { callbackQCheckBox_StateChanged(this, state); };
	 ~MyQCheckBox() { callbackQCheckBox_DestroyQCheckBox(this); };
	void animateClick(int msec) { callbackQAbstractButton_AnimateClick(this, msec); };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void click() { callbackQAbstractButton_Click(this); };
	void Signal_Clicked(bool checked) { callbackQAbstractButton_Clicked(this, checked); };
	void focusInEvent(QFocusEvent * e) { callbackQWidget_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQWidget_FocusOutEvent(this, e); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQWidget_KeyReleaseEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void Signal_Pressed() { callbackQAbstractButton_Pressed(this); };
	void Signal_Released() { callbackQAbstractButton_Released(this); };
	void setChecked(bool vbo) { callbackQAbstractButton_SetChecked(this, vbo); };
	void setIconSize(const QSize & size) { callbackQAbstractButton_SetIconSize(this, const_cast<QSize*>(&size)); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void toggle() { callbackQAbstractButton_Toggle(this); };
	void Signal_Toggled(bool checked) { callbackQAbstractButton_Toggled(this, checked); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QCheckBox*)
Q_DECLARE_METATYPE(MyQCheckBox*)

int QCheckBox_QCheckBox_QRegisterMetaType(){qRegisterMetaType<QCheckBox*>(); return qRegisterMetaType<MyQCheckBox*>();}

void* QCheckBox_NewQCheckBox(void* parent)
{
		return new MyQCheckBox(static_cast<QWidget*>(parent));
}

void* QCheckBox_NewQCheckBox2(struct QtWidgets_PackedString text, void* parent)
{
		return new MyQCheckBox(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(parent));
}

long long QCheckBox_CheckState(void* ptr)
{
	return static_cast<QCheckBox*>(ptr)->checkState();
}

void QCheckBox_InitStyleOption(void* ptr, void* option)
{
	static_cast<QCheckBox*>(ptr)->initStyleOption(static_cast<QStyleOptionButton*>(option));
}

char QCheckBox_IsTristate(void* ptr)
{
	return static_cast<QCheckBox*>(ptr)->isTristate();
}

void QCheckBox_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QCheckBox*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QCheckBox_PaintEventDefault(void* ptr, void* vqp)
{
		static_cast<QCheckBox*>(ptr)->QCheckBox::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QCheckBox_SetCheckState(void* ptr, long long state)
{
	static_cast<QCheckBox*>(ptr)->setCheckState(static_cast<Qt::CheckState>(state));
}

void QCheckBox_SetTristate(void* ptr, char y)
{
	static_cast<QCheckBox*>(ptr)->setTristate(y != 0);
}

void QCheckBox_ConnectStateChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QCheckBox*>(ptr), static_cast<void (QCheckBox::*)(int)>(&QCheckBox::stateChanged), static_cast<MyQCheckBox*>(ptr), static_cast<void (MyQCheckBox::*)(int)>(&MyQCheckBox::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QCheckBox_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QCheckBox*>(ptr), static_cast<void (QCheckBox::*)(int)>(&QCheckBox::stateChanged), static_cast<MyQCheckBox*>(ptr), static_cast<void (MyQCheckBox::*)(int)>(&MyQCheckBox::Signal_StateChanged));
}

void QCheckBox_StateChanged(void* ptr, int state)
{
	static_cast<QCheckBox*>(ptr)->stateChanged(state);
}

void QCheckBox_DestroyQCheckBox(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->~QCheckBox();
}

void QCheckBox_DestroyQCheckBoxDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQColorDialog: public QColorDialog
{
public:
	MyQColorDialog(QWidget *parent = Q_NULLPTR) : QColorDialog(parent) {QColorDialog_QColorDialog_QRegisterMetaType();};
	MyQColorDialog(const QColor &initial, QWidget *parent = Q_NULLPTR) : QColorDialog(initial, parent) {QColorDialog_QColorDialog_QRegisterMetaType();};
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void Signal_ColorSelected(const QColor & color) { callbackQColorDialog_ColorSelected(this, const_cast<QColor*>(&color)); };
	void Signal_CurrentColorChanged(const QColor & color) { callbackQColorDialog_CurrentColorChanged(this, const_cast<QColor*>(&color)); };
	void done(int result) { callbackQColorDialog_Done(this, result); };
	void setVisible(bool visible) { callbackQDialog_SetVisible(this, visible); };
	 ~MyQColorDialog() { callbackQColorDialog_DestroyQColorDialog(this); };
	void accept() { callbackQDialog_Accept(this); };
	void Signal_Accepted() { callbackQDialog_Accepted(this); };
	void closeEvent(QCloseEvent * e) { callbackQWidget_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	bool eventFilter(QObject * o, QEvent * e) { return callbackQWidget_EventFilter(this, o, e) != 0; };
	int exec() { return callbackQDialog_Exec(this); };
	void Signal_Finished(int result) { callbackQDialog_Finished(this, result); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void reject() { callbackQDialog_Reject(this); };
	void Signal_Rejected() { callbackQDialog_Rejected(this); };
	void resizeEvent(QResizeEvent * vqr) { callbackQWidget_ResizeEvent(this, vqr); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QColorDialog*)
Q_DECLARE_METATYPE(MyQColorDialog*)

int QColorDialog_QColorDialog_QRegisterMetaType(){qRegisterMetaType<QColorDialog*>(); return qRegisterMetaType<MyQColorDialog*>();}

void* QColorDialog_NewQColorDialog(void* parent)
{
		return new MyQColorDialog(static_cast<QWidget*>(parent));
}

void* QColorDialog_NewQColorDialog2(void* initial, void* parent)
{
		return new MyQColorDialog(*static_cast<QColor*>(initial), static_cast<QWidget*>(parent));
}

void QColorDialog_ConnectColorSelected(void* ptr, long long t)
{
	QObject::connect(static_cast<QColorDialog*>(ptr), static_cast<void (QColorDialog::*)(const QColor &)>(&QColorDialog::colorSelected), static_cast<MyQColorDialog*>(ptr), static_cast<void (MyQColorDialog::*)(const QColor &)>(&MyQColorDialog::Signal_ColorSelected), static_cast<Qt::ConnectionType>(t));
}

void QColorDialog_DisconnectColorSelected(void* ptr)
{
	QObject::disconnect(static_cast<QColorDialog*>(ptr), static_cast<void (QColorDialog::*)(const QColor &)>(&QColorDialog::colorSelected), static_cast<MyQColorDialog*>(ptr), static_cast<void (MyQColorDialog::*)(const QColor &)>(&MyQColorDialog::Signal_ColorSelected));
}

void QColorDialog_ColorSelected(void* ptr, void* color)
{
	static_cast<QColorDialog*>(ptr)->colorSelected(*static_cast<QColor*>(color));
}

void* QColorDialog_CurrentColor(void* ptr)
{
	return new QColor(static_cast<QColorDialog*>(ptr)->currentColor());
}

void QColorDialog_ConnectCurrentColorChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QColorDialog*>(ptr), static_cast<void (QColorDialog::*)(const QColor &)>(&QColorDialog::currentColorChanged), static_cast<MyQColorDialog*>(ptr), static_cast<void (MyQColorDialog::*)(const QColor &)>(&MyQColorDialog::Signal_CurrentColorChanged), static_cast<Qt::ConnectionType>(t));
}

void QColorDialog_DisconnectCurrentColorChanged(void* ptr)
{
	QObject::disconnect(static_cast<QColorDialog*>(ptr), static_cast<void (QColorDialog::*)(const QColor &)>(&QColorDialog::currentColorChanged), static_cast<MyQColorDialog*>(ptr), static_cast<void (MyQColorDialog::*)(const QColor &)>(&MyQColorDialog::Signal_CurrentColorChanged));
}

void QColorDialog_CurrentColorChanged(void* ptr, void* color)
{
	static_cast<QColorDialog*>(ptr)->currentColorChanged(*static_cast<QColor*>(color));
}

void* QColorDialog_QColorDialog_CustomColor(int index)
{
	return new QColor(QColorDialog::customColor(index));
}

int QColorDialog_QColorDialog_CustomCount()
{
	return QColorDialog::customCount();
}

void QColorDialog_Done(void* ptr, int result)
{
	static_cast<QColorDialog*>(ptr)->done(result);
}

void QColorDialog_DoneDefault(void* ptr, int result)
{
		static_cast<QColorDialog*>(ptr)->QColorDialog::done(result);
}

void* QColorDialog_QColorDialog_GetColor(void* initial, void* parent, struct QtWidgets_PackedString title, long long options)
{
		return new QColor(QColorDialog::getColor(*static_cast<QColor*>(initial), static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len), static_cast<QColorDialog::ColorDialogOption>(options)));
}

void QColorDialog_Open(void* ptr, void* receiver, char* member)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(receiver))) {
		static_cast<QColorDialog*>(ptr)->open(static_cast<QGraphicsObject*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(receiver))) {
		static_cast<QColorDialog*>(ptr)->open(static_cast<QGraphicsWidget*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(receiver))) {
		static_cast<QColorDialog*>(ptr)->open(static_cast<QLayout*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(receiver))) {
		static_cast<QColorDialog*>(ptr)->open(static_cast<QWidget*>(receiver), const_cast<const char*>(member));
	} else {
		static_cast<QColorDialog*>(ptr)->open(static_cast<QObject*>(receiver), const_cast<const char*>(member));
	}
}

long long QColorDialog_Options(void* ptr)
{
	return static_cast<QColorDialog*>(ptr)->options();
}

void* QColorDialog_SelectedColor(void* ptr)
{
	return new QColor(static_cast<QColorDialog*>(ptr)->selectedColor());
}

void QColorDialog_SetCurrentColor(void* ptr, void* color)
{
	static_cast<QColorDialog*>(ptr)->setCurrentColor(*static_cast<QColor*>(color));
}

void QColorDialog_QColorDialog_SetCustomColor(int index, void* color)
{
	QColorDialog::setCustomColor(index, *static_cast<QColor*>(color));
}

void QColorDialog_SetOption(void* ptr, long long option, char on)
{
	static_cast<QColorDialog*>(ptr)->setOption(static_cast<QColorDialog::ColorDialogOption>(option), on != 0);
}

void QColorDialog_SetOptions(void* ptr, long long options)
{
	static_cast<QColorDialog*>(ptr)->setOptions(static_cast<QColorDialog::ColorDialogOption>(options));
}

void QColorDialog_QColorDialog_SetStandardColor(int index, void* color)
{
	QColorDialog::setStandardColor(index, *static_cast<QColor*>(color));
}

void* QColorDialog_QColorDialog_StandardColor(int index)
{
	return new QColor(QColorDialog::standardColor(index));
}

char QColorDialog_TestOption(void* ptr, long long option)
{
	return static_cast<QColorDialog*>(ptr)->testOption(static_cast<QColorDialog::ColorDialogOption>(option));
}

void QColorDialog_DestroyQColorDialog(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->~QColorDialog();
}

void QColorDialog_DestroyQColorDialogDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

Q_DECLARE_METATYPE(QColormap*)
void* QColormap_NewQColormap(void* colormap)
{
	return new QColormap(*static_cast<QColormap*>(colormap));
}

void* QColormap_ColorAt(void* ptr, unsigned int pixel)
{
	return new QColor(static_cast<QColormap*>(ptr)->colorAt(pixel));
}

struct QtWidgets_PackedList QColormap_Colormap(void* ptr)
{
	return ({ QVector<QColor>* tmpValue60e802 = new QVector<QColor>(static_cast<QColormap*>(ptr)->colormap()); QtWidgets_PackedList { tmpValue60e802, tmpValue60e802->size() }; });
}

int QColormap_Depth(void* ptr)
{
	return static_cast<QColormap*>(ptr)->depth();
}

void* QColormap_QColormap_Instance(int screen)
{
	return new QColormap(QColormap::instance(screen));
}

long long QColormap_Mode(void* ptr)
{
	return static_cast<QColormap*>(ptr)->mode();
}

unsigned int QColormap_Pixel(void* ptr, void* color)
{
	return static_cast<QColormap*>(ptr)->pixel(*static_cast<QColor*>(color));
}

int QColormap_Size(void* ptr)
{
	return static_cast<QColormap*>(ptr)->size();
}

void QColormap_DestroyQColormap(void* ptr)
{
	static_cast<QColormap*>(ptr)->~QColormap();
}

void* QColormap___colormap_atList(void* ptr, int i)
{
	return new QColor(({QColor tmp = static_cast<QVector<QColor>*>(ptr)->at(i); if (i == static_cast<QVector<QColor>*>(ptr)->size()-1) { static_cast<QVector<QColor>*>(ptr)->~QVector(); free(ptr); }; tmp; }));
}

void QColormap___colormap_setList(void* ptr, void* i)
{
	static_cast<QVector<QColor>*>(ptr)->append(*static_cast<QColor*>(i));
}

void* QColormap___colormap_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<QColor>();
}

class MyQColumnView: public QColumnView
{
public:
	MyQColumnView(QWidget *parent = Q_NULLPTR) : QColumnView(parent) {QColumnView_QColumnView_QRegisterMetaType();};
	QAbstractItemView * createColumn(const QModelIndex & index) { return static_cast<QAbstractItemView*>(callbackQColumnView_CreateColumn(this, const_cast<QModelIndex*>(&index))); };
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQColumnView_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	int horizontalOffset() const { return callbackQColumnView_HorizontalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQColumnView_IndexAt(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&point))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQColumnView_IsIndexHidden(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index)) != 0; };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQColumnView_MoveCursor(this, cursorAction, modifiers)); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQColumnView_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQColumnView_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	void selectAll() { callbackQColumnView_SelectAll(this); };
	void setModel(QAbstractItemModel * model) { callbackQAbstractItemView_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQColumnView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQColumnView_SetSelection(this, const_cast<QRect*>(&rect), command); };
	void setSelectionModel(QItemSelectionModel * newSelectionModel) { callbackQAbstractItemView_SetSelectionModel(this, newSelectionModel); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_UpdatePreviewWidget(const QModelIndex & index) { callbackQColumnView_UpdatePreviewWidget(this, const_cast<QModelIndex*>(&index)); };
	int verticalOffset() const { return callbackQColumnView_VerticalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQColumnView_VisualRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQColumnView_VisualRegionForSelection(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&selection))); };
	 ~MyQColumnView() { callbackQColumnView_DestroyQColumnView(this); };
	void Signal_Activated(const QModelIndex & index) { callbackQAbstractItemView_Activated(this, const_cast<QModelIndex*>(&index)); };
	void clearSelection() { callbackQAbstractItemView_ClearSelection(this); };
	void Signal_Clicked(const QModelIndex & index) { callbackQAbstractItemView_Clicked(this, const_cast<QModelIndex*>(&index)); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQAbstractItemView_CommitData(this, editor); };
	void dataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemView_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
	void Signal_DoubleClicked(const QModelIndex & index) { callbackQAbstractItemView_DoubleClicked(this, const_cast<QModelIndex*>(&index)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQAbstractItemView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQAbstractItemView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQAbstractItemView_EditorDestroyed(this, editor); };
	void Signal_Entered(const QModelIndex & index) { callbackQAbstractItemView_Entered(this, const_cast<QModelIndex*>(&index)); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQWidget_EventFilter(this, object, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void Signal_IconSizeChanged(const QSize & size) { callbackQAbstractItemView_IconSizeChanged(this, const_cast<QSize*>(&size)); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { QByteArray* t3559d7 = new QByteArray(search.toUtf8()); QtWidgets_PackedString searchPacked = { const_cast<char*>(t3559d7->prepend("WHITESPACE").constData()+10), t3559d7->size()-10, t3559d7 };callbackQAbstractItemView_KeyboardSearch(this, searchPacked); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void Signal_Pressed(const QModelIndex & index) { callbackQAbstractItemView_Pressed(this, const_cast<QModelIndex*>(&index)); };
	void reset() { callbackQAbstractItemView_Reset(this); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQAbstractItemView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollToBottom() { callbackQAbstractItemView_ScrollToBottom(this); };
	void scrollToTop() { callbackQAbstractItemView_ScrollToTop(this); };
	QList<QModelIndex> selectedIndexes() const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemView_SelectedIndexes(const_cast<void*>(static_cast<const void*>(this)))); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQAbstractItemView_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQAbstractItemView_SelectionCommand(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQAbstractItemView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	int sizeHintForColumn(int column) const { return callbackQAbstractItemView_SizeHintForColumn(const_cast<void*>(static_cast<const void*>(this)), column); };
	int sizeHintForRow(int row) const { return callbackQAbstractItemView_SizeHintForRow(const_cast<void*>(static_cast<const void*>(this)), row); };
	void startDrag(Qt::DropActions supportedActions) { callbackQAbstractItemView_StartDrag(this, supportedActions); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	void update(const QModelIndex & index) { callbackQAbstractItemView_Update(this, const_cast<QModelIndex*>(&index)); };
	void updateGeometries() { callbackQAbstractItemView_UpdateGeometries(this); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQAbstractItemView_ViewOptions(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ViewportEntered() { callbackQAbstractItemView_ViewportEntered(this); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QColumnView*)
Q_DECLARE_METATYPE(MyQColumnView*)

int QColumnView_QColumnView_QRegisterMetaType(){qRegisterMetaType<QColumnView*>(); return qRegisterMetaType<MyQColumnView*>();}

void* QColumnView_NewQColumnView(void* parent)
{
		return new MyQColumnView(static_cast<QWidget*>(parent));
}

struct QtWidgets_PackedList QColumnView_ColumnWidths(void* ptr)
{
	return ({ QList<int>* tmpValuef750bc = new QList<int>(static_cast<QColumnView*>(ptr)->columnWidths()); QtWidgets_PackedList { tmpValuef750bc, tmpValuef750bc->size() }; });
}

void* QColumnView_CreateColumn(void* ptr, void* index)
{
	return static_cast<QColumnView*>(ptr)->createColumn(*static_cast<QModelIndex*>(index));
}

void* QColumnView_CreateColumnDefault(void* ptr, void* index)
{
		return static_cast<QColumnView*>(ptr)->QColumnView::createColumn(*static_cast<QModelIndex*>(index));
}

void QColumnView_CurrentChanged(void* ptr, void* current, void* previous)
{
	static_cast<QColumnView*>(ptr)->currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QColumnView_CurrentChangedDefault(void* ptr, void* current, void* previous)
{
		static_cast<QColumnView*>(ptr)->QColumnView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

int QColumnView_HorizontalOffset(void* ptr)
{
	return static_cast<QColumnView*>(ptr)->horizontalOffset();
}

int QColumnView_HorizontalOffsetDefault(void* ptr)
{
		return static_cast<QColumnView*>(ptr)->QColumnView::horizontalOffset();
}

void* QColumnView_IndexAt(void* ptr, void* point)
{
	return new QModelIndex(static_cast<QColumnView*>(ptr)->indexAt(*static_cast<QPoint*>(point)));
}

void* QColumnView_IndexAtDefault(void* ptr, void* point)
{
		return new QModelIndex(static_cast<QColumnView*>(ptr)->QColumnView::indexAt(*static_cast<QPoint*>(point)));
}

void QColumnView_InitializeColumn(void* ptr, void* column)
{
	static_cast<QColumnView*>(ptr)->initializeColumn(static_cast<QAbstractItemView*>(column));
}

char QColumnView_IsIndexHidden(void* ptr, void* index)
{
	return static_cast<QColumnView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}

char QColumnView_IsIndexHiddenDefault(void* ptr, void* index)
{
		return static_cast<QColumnView*>(ptr)->QColumnView::isIndexHidden(*static_cast<QModelIndex*>(index));
}

void* QColumnView_MoveCursor(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QColumnView*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void* QColumnView_MoveCursorDefault(void* ptr, long long cursorAction, long long modifiers)
{
		return new QModelIndex(static_cast<QColumnView*>(ptr)->QColumnView::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void* QColumnView_PreviewWidget(void* ptr)
{
	return static_cast<QColumnView*>(ptr)->previewWidget();
}

char QColumnView_ResizeGripsVisible(void* ptr)
{
	return static_cast<QColumnView*>(ptr)->resizeGripsVisible();
}

void QColumnView_RowsInserted(void* ptr, void* parent, int start, int end)
{
	static_cast<QColumnView*>(ptr)->rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
}

void QColumnView_RowsInsertedDefault(void* ptr, void* parent, int start, int end)
{
		static_cast<QColumnView*>(ptr)->QColumnView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
}

void QColumnView_ScrollTo(void* ptr, void* index, long long hint)
{
	static_cast<QColumnView*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QColumnView_ScrollToDefault(void* ptr, void* index, long long hint)
{
		static_cast<QColumnView*>(ptr)->QColumnView::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QColumnView_SelectAll(void* ptr)
{
	static_cast<QColumnView*>(ptr)->selectAll();
}

void QColumnView_SelectAllDefault(void* ptr)
{
		static_cast<QColumnView*>(ptr)->QColumnView::selectAll();
}

void QColumnView_SetColumnWidths(void* ptr, void* list)
{
	static_cast<QColumnView*>(ptr)->setColumnWidths(*static_cast<QList<int>*>(list));
}

void QColumnView_SetPreviewWidget(void* ptr, void* widget)
{
		static_cast<QColumnView*>(ptr)->setPreviewWidget(static_cast<QWidget*>(widget));
}

void QColumnView_SetResizeGripsVisible(void* ptr, char visible)
{
	static_cast<QColumnView*>(ptr)->setResizeGripsVisible(visible != 0);
}

void QColumnView_SetRootIndex(void* ptr, void* index)
{
	static_cast<QColumnView*>(ptr)->setRootIndex(*static_cast<QModelIndex*>(index));
}

void QColumnView_SetRootIndexDefault(void* ptr, void* index)
{
		static_cast<QColumnView*>(ptr)->QColumnView::setRootIndex(*static_cast<QModelIndex*>(index));
}

void QColumnView_SetSelection(void* ptr, void* rect, long long command)
{
	static_cast<QColumnView*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QColumnView_SetSelectionDefault(void* ptr, void* rect, long long command)
{
		static_cast<QColumnView*>(ptr)->QColumnView::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QColumnView_ConnectUpdatePreviewWidget(void* ptr, long long t)
{
	QObject::connect(static_cast<QColumnView*>(ptr), static_cast<void (QColumnView::*)(const QModelIndex &)>(&QColumnView::updatePreviewWidget), static_cast<MyQColumnView*>(ptr), static_cast<void (MyQColumnView::*)(const QModelIndex &)>(&MyQColumnView::Signal_UpdatePreviewWidget), static_cast<Qt::ConnectionType>(t));
}

void QColumnView_DisconnectUpdatePreviewWidget(void* ptr)
{
	QObject::disconnect(static_cast<QColumnView*>(ptr), static_cast<void (QColumnView::*)(const QModelIndex &)>(&QColumnView::updatePreviewWidget), static_cast<MyQColumnView*>(ptr), static_cast<void (MyQColumnView::*)(const QModelIndex &)>(&MyQColumnView::Signal_UpdatePreviewWidget));
}

void QColumnView_UpdatePreviewWidget(void* ptr, void* index)
{
	static_cast<QColumnView*>(ptr)->updatePreviewWidget(*static_cast<QModelIndex*>(index));
}

int QColumnView_VerticalOffset(void* ptr)
{
	return static_cast<QColumnView*>(ptr)->verticalOffset();
}

int QColumnView_VerticalOffsetDefault(void* ptr)
{
		return static_cast<QColumnView*>(ptr)->QColumnView::verticalOffset();
}

void* QColumnView_VisualRect(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QColumnView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QColumnView_VisualRectDefault(void* ptr, void* index)
{
		return ({ QRect tmpValue = static_cast<QColumnView*>(ptr)->QColumnView::visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QColumnView_VisualRegionForSelection(void* ptr, void* selection)
{
	return new QRegion(static_cast<QColumnView*>(ptr)->visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void* QColumnView_VisualRegionForSelectionDefault(void* ptr, void* selection)
{
		return new QRegion(static_cast<QColumnView*>(ptr)->QColumnView::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void QColumnView_DestroyQColumnView(void* ptr)
{
	static_cast<QColumnView*>(ptr)->~QColumnView();
}

void QColumnView_DestroyQColumnViewDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

int QColumnView___columnWidths_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

int QColumnView___setColumnWidths_list_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

class MyQComboBox: public QComboBox
{
public:
	MyQComboBox(QWidget *parent = Q_NULLPTR) : QComboBox(parent) {QComboBox_QComboBox_QRegisterMetaType();};
	void Signal_Activated(int index) { callbackQComboBox_Activated(this, index); };
	void Signal_Activated2(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQComboBox_Activated2(this, textPacked); };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void clear() { callbackQComboBox_Clear(this); };
	void clearEditText() { callbackQComboBox_ClearEditText(this); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	void Signal_CurrentIndexChanged(int index) { callbackQComboBox_CurrentIndexChanged(this, index); };
	void Signal_CurrentTextChanged(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQComboBox_CurrentTextChanged(this, textPacked); };
	void Signal_EditTextChanged(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQComboBox_EditTextChanged(this, textPacked); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * e) { callbackQWidget_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQWidget_FocusOutEvent(this, e); };
	void hideEvent(QHideEvent * e) { callbackQWidget_HideEvent(this, e); };
	void hidePopup() { callbackQComboBox_HidePopup(this); };
	void Signal_Highlighted(int index) { callbackQComboBox_Highlighted(this, index); };
	void Signal_Highlighted2(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQComboBox_Highlighted2(this, textPacked); };
	void inputMethodEvent(QInputMethodEvent * e) { callbackQWidget_InputMethodEvent(this, e); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQWidget_KeyReleaseEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQWidget_PaintEvent(this, e); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void setCurrentIndex(int index) { callbackQComboBox_SetCurrentIndex(this, index); };
	void setCurrentText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQComboBox_SetCurrentText(this, textPacked); };
	void setEditText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQComboBox_SetEditText(this, textPacked); };
	void showEvent(QShowEvent * e) { callbackQWidget_ShowEvent(this, e); };
	void showPopup() { callbackQComboBox_ShowPopup(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	 ~MyQComboBox() { callbackQComboBox_DestroyQComboBox(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QComboBox*)
Q_DECLARE_METATYPE(MyQComboBox*)

int QComboBox_QComboBox_QRegisterMetaType(){qRegisterMetaType<QComboBox*>(); return qRegisterMetaType<MyQComboBox*>();}

void* QComboBox_NewQComboBox(void* parent)
{
		return new MyQComboBox(static_cast<QWidget*>(parent));
}

void QComboBox_ConnectActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(int)>(&MyQComboBox::Signal_Activated), static_cast<Qt::ConnectionType>(t));
}

void QComboBox_DisconnectActivated(void* ptr)
{
	QObject::disconnect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(int)>(&MyQComboBox::Signal_Activated));
}

void QComboBox_Activated(void* ptr, int index)
{
	static_cast<QComboBox*>(ptr)->activated(index);
}

void QComboBox_ConnectActivated2(void* ptr, long long t)
{
	QObject::connect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::activated), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(const QString &)>(&MyQComboBox::Signal_Activated2), static_cast<Qt::ConnectionType>(t));
}

void QComboBox_DisconnectActivated2(void* ptr)
{
	QObject::disconnect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::activated), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(const QString &)>(&MyQComboBox::Signal_Activated2));
}

void QComboBox_Activated2(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QComboBox*>(ptr)->activated(QString::fromUtf8(text.data, text.len));
}

void QComboBox_AddItem(void* ptr, struct QtWidgets_PackedString text, void* userData)
{
	static_cast<QComboBox*>(ptr)->addItem(QString::fromUtf8(text.data, text.len), *static_cast<QVariant*>(userData));
}

void QComboBox_AddItem2(void* ptr, void* icon, struct QtWidgets_PackedString text, void* userData)
{
	static_cast<QComboBox*>(ptr)->addItem(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), *static_cast<QVariant*>(userData));
}

void QComboBox_AddItems(void* ptr, struct QtWidgets_PackedString texts)
{
	static_cast<QComboBox*>(ptr)->addItems(QString::fromUtf8(texts.data, texts.len).split("¡¦!", QString::SkipEmptyParts));
}

void QComboBox_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "clear");
}

void QComboBox_ClearDefault(void* ptr)
{
	if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::clear();
	} else {
		static_cast<QComboBox*>(ptr)->QComboBox::clear();
	}
}

void QComboBox_ClearEditText(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "clearEditText");
}

void QComboBox_ClearEditTextDefault(void* ptr)
{
	if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::clearEditText();
	} else {
		static_cast<QComboBox*>(ptr)->QComboBox::clearEditText();
	}
}

void* QComboBox_Completer(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->completer();
}

int QComboBox_Count(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->count();
}

void* QComboBox_CurrentData(void* ptr, int role)
{
	return new QVariant(static_cast<QComboBox*>(ptr)->currentData(role));
}

int QComboBox_CurrentIndex(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->currentIndex();
}

void QComboBox_ConnectCurrentIndexChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(int)>(&MyQComboBox::Signal_CurrentIndexChanged), static_cast<Qt::ConnectionType>(t));
}

void QComboBox_DisconnectCurrentIndexChanged(void* ptr)
{
	QObject::disconnect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(int)>(&MyQComboBox::Signal_CurrentIndexChanged));
}

void QComboBox_CurrentIndexChanged(void* ptr, int index)
{
	static_cast<QComboBox*>(ptr)->currentIndexChanged(index);
}

struct QtWidgets_PackedString QComboBox_CurrentText(void* ptr)
{
	return ({ QByteArray* t0977ce = new QByteArray(static_cast<QComboBox*>(ptr)->currentText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t0977ce->prepend("WHITESPACE").constData()+10), t0977ce->size()-10, t0977ce }; });
}

void QComboBox_ConnectCurrentTextChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::currentTextChanged), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(const QString &)>(&MyQComboBox::Signal_CurrentTextChanged), static_cast<Qt::ConnectionType>(t));
}

void QComboBox_DisconnectCurrentTextChanged(void* ptr)
{
	QObject::disconnect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::currentTextChanged), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(const QString &)>(&MyQComboBox::Signal_CurrentTextChanged));
}

void QComboBox_CurrentTextChanged(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QComboBox*>(ptr)->currentTextChanged(QString::fromUtf8(text.data, text.len));
}

char QComboBox_DuplicatesEnabled(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->duplicatesEnabled();
}

void QComboBox_ConnectEditTextChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::editTextChanged), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(const QString &)>(&MyQComboBox::Signal_EditTextChanged), static_cast<Qt::ConnectionType>(t));
}

void QComboBox_DisconnectEditTextChanged(void* ptr)
{
	QObject::disconnect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::editTextChanged), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(const QString &)>(&MyQComboBox::Signal_EditTextChanged));
}

void QComboBox_EditTextChanged(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QComboBox*>(ptr)->editTextChanged(QString::fromUtf8(text.data, text.len));
}

int QComboBox_FindData(void* ptr, void* data, int role, long long flags)
{
	return static_cast<QComboBox*>(ptr)->findData(*static_cast<QVariant*>(data), role, static_cast<Qt::MatchFlag>(flags));
}

int QComboBox_FindText(void* ptr, struct QtWidgets_PackedString text, long long flags)
{
	return static_cast<QComboBox*>(ptr)->findText(QString::fromUtf8(text.data, text.len), static_cast<Qt::MatchFlag>(flags));
}

char QComboBox_HasFrame(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->hasFrame();
}

void QComboBox_HidePopup(void* ptr)
{
	static_cast<QComboBox*>(ptr)->hidePopup();
}

void QComboBox_HidePopupDefault(void* ptr)
{
	if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::hidePopup();
	} else {
		static_cast<QComboBox*>(ptr)->QComboBox::hidePopup();
	}
}

void QComboBox_ConnectHighlighted(void* ptr, long long t)
{
	QObject::connect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(int)>(&QComboBox::highlighted), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(int)>(&MyQComboBox::Signal_Highlighted), static_cast<Qt::ConnectionType>(t));
}

void QComboBox_DisconnectHighlighted(void* ptr)
{
	QObject::disconnect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(int)>(&QComboBox::highlighted), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(int)>(&MyQComboBox::Signal_Highlighted));
}

void QComboBox_Highlighted(void* ptr, int index)
{
	static_cast<QComboBox*>(ptr)->highlighted(index);
}

void QComboBox_ConnectHighlighted2(void* ptr, long long t)
{
	QObject::connect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::highlighted), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(const QString &)>(&MyQComboBox::Signal_Highlighted2), static_cast<Qt::ConnectionType>(t));
}

void QComboBox_DisconnectHighlighted2(void* ptr)
{
	QObject::disconnect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::highlighted), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(const QString &)>(&MyQComboBox::Signal_Highlighted2));
}

void QComboBox_Highlighted2(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QComboBox*>(ptr)->highlighted(QString::fromUtf8(text.data, text.len));
}

void* QComboBox_IconSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QComboBox*>(ptr)->iconSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QComboBox_InitStyleOption(void* ptr, void* option)
{
	static_cast<QComboBox*>(ptr)->initStyleOption(static_cast<QStyleOptionComboBox*>(option));
}

void QComboBox_InsertItem(void* ptr, int index, struct QtWidgets_PackedString text, void* userData)
{
	static_cast<QComboBox*>(ptr)->insertItem(index, QString::fromUtf8(text.data, text.len), *static_cast<QVariant*>(userData));
}

void QComboBox_InsertItem2(void* ptr, int index, void* icon, struct QtWidgets_PackedString text, void* userData)
{
	static_cast<QComboBox*>(ptr)->insertItem(index, *static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), *static_cast<QVariant*>(userData));
}

void QComboBox_InsertItems(void* ptr, int index, struct QtWidgets_PackedString list)
{
	static_cast<QComboBox*>(ptr)->insertItems(index, QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts));
}

long long QComboBox_InsertPolicy(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->insertPolicy();
}

void QComboBox_InsertSeparator(void* ptr, int index)
{
	static_cast<QComboBox*>(ptr)->insertSeparator(index);
}

char QComboBox_IsEditable(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->isEditable();
}

void* QComboBox_ItemData(void* ptr, int index, int role)
{
	return new QVariant(static_cast<QComboBox*>(ptr)->itemData(index, role));
}

void* QComboBox_ItemDelegate(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->itemDelegate();
}

void* QComboBox_ItemIcon(void* ptr, int index)
{
	return new QIcon(static_cast<QComboBox*>(ptr)->itemIcon(index));
}

struct QtWidgets_PackedString QComboBox_ItemText(void* ptr, int index)
{
	return ({ QByteArray* tda5d0a = new QByteArray(static_cast<QComboBox*>(ptr)->itemText(index).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tda5d0a->prepend("WHITESPACE").constData()+10), tda5d0a->size()-10, tda5d0a }; });
}

void* QComboBox_LineEdit(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->lineEdit();
}

int QComboBox_MaxCount(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->maxCount();
}

int QComboBox_MaxVisibleItems(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->maxVisibleItems();
}

int QComboBox_MinimumContentsLength(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->minimumContentsLength();
}

void* QComboBox_Model(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->model();
}

int QComboBox_ModelColumn(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->modelColumn();
}

void QComboBox_RemoveItem(void* ptr, int index)
{
	static_cast<QComboBox*>(ptr)->removeItem(index);
}

void* QComboBox_RootModelIndex(void* ptr)
{
	return new QModelIndex(static_cast<QComboBox*>(ptr)->rootModelIndex());
}

void QComboBox_SetCompleter(void* ptr, void* completer)
{
	static_cast<QComboBox*>(ptr)->setCompleter(static_cast<QCompleter*>(completer));
}

void QComboBox_SetCurrentIndex(void* ptr, int index)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setCurrentIndex", Q_ARG(int, index));
}

void QComboBox_SetCurrentIndexDefault(void* ptr, int index)
{
	if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setCurrentIndex(index);
	} else {
		static_cast<QComboBox*>(ptr)->QComboBox::setCurrentIndex(index);
	}
}

void QComboBox_SetCurrentText(void* ptr, struct QtWidgets_PackedString text)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setCurrentText", Q_ARG(const QString, QString::fromUtf8(text.data, text.len)));
}

void QComboBox_SetCurrentTextDefault(void* ptr, struct QtWidgets_PackedString text)
{
	if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setCurrentText(QString::fromUtf8(text.data, text.len));
	} else {
		static_cast<QComboBox*>(ptr)->QComboBox::setCurrentText(QString::fromUtf8(text.data, text.len));
	}
}

void QComboBox_SetDuplicatesEnabled(void* ptr, char enable)
{
	static_cast<QComboBox*>(ptr)->setDuplicatesEnabled(enable != 0);
}

void QComboBox_SetEditText(void* ptr, struct QtWidgets_PackedString text)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setEditText", Q_ARG(const QString, QString::fromUtf8(text.data, text.len)));
}

void QComboBox_SetEditTextDefault(void* ptr, struct QtWidgets_PackedString text)
{
	if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setEditText(QString::fromUtf8(text.data, text.len));
	} else {
		static_cast<QComboBox*>(ptr)->QComboBox::setEditText(QString::fromUtf8(text.data, text.len));
	}
}

void QComboBox_SetEditable(void* ptr, char editable)
{
	static_cast<QComboBox*>(ptr)->setEditable(editable != 0);
}

void QComboBox_SetFrame(void* ptr, char vbo)
{
	static_cast<QComboBox*>(ptr)->setFrame(vbo != 0);
}

void QComboBox_SetIconSize(void* ptr, void* size)
{
	static_cast<QComboBox*>(ptr)->setIconSize(*static_cast<QSize*>(size));
}

void QComboBox_SetInsertPolicy(void* ptr, long long policy)
{
	static_cast<QComboBox*>(ptr)->setInsertPolicy(static_cast<QComboBox::InsertPolicy>(policy));
}

void QComboBox_SetItemData(void* ptr, int index, void* value, int role)
{
	static_cast<QComboBox*>(ptr)->setItemData(index, *static_cast<QVariant*>(value), role);
}

void QComboBox_SetItemDelegate(void* ptr, void* delegate)
{
	static_cast<QComboBox*>(ptr)->setItemDelegate(static_cast<QAbstractItemDelegate*>(delegate));
}

void QComboBox_SetItemIcon(void* ptr, int index, void* icon)
{
	static_cast<QComboBox*>(ptr)->setItemIcon(index, *static_cast<QIcon*>(icon));
}

void QComboBox_SetItemText(void* ptr, int index, struct QtWidgets_PackedString text)
{
	static_cast<QComboBox*>(ptr)->setItemText(index, QString::fromUtf8(text.data, text.len));
}

void QComboBox_SetLineEdit(void* ptr, void* edit)
{
	static_cast<QComboBox*>(ptr)->setLineEdit(static_cast<QLineEdit*>(edit));
}

void QComboBox_SetMaxCount(void* ptr, int max)
{
	static_cast<QComboBox*>(ptr)->setMaxCount(max);
}

void QComboBox_SetMaxVisibleItems(void* ptr, int maxItems)
{
	static_cast<QComboBox*>(ptr)->setMaxVisibleItems(maxItems);
}

void QComboBox_SetMinimumContentsLength(void* ptr, int characters)
{
	static_cast<QComboBox*>(ptr)->setMinimumContentsLength(characters);
}

void QComboBox_SetModel(void* ptr, void* model)
{
	static_cast<QComboBox*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}

void QComboBox_SetModelColumn(void* ptr, int visibleColumn)
{
	static_cast<QComboBox*>(ptr)->setModelColumn(visibleColumn);
}

void QComboBox_SetRootModelIndex(void* ptr, void* index)
{
	static_cast<QComboBox*>(ptr)->setRootModelIndex(*static_cast<QModelIndex*>(index));
}

void QComboBox_SetSizeAdjustPolicy(void* ptr, long long policy)
{
	static_cast<QComboBox*>(ptr)->setSizeAdjustPolicy(static_cast<QComboBox::SizeAdjustPolicy>(policy));
}

void QComboBox_SetValidator(void* ptr, void* validator)
{
	static_cast<QComboBox*>(ptr)->setValidator(static_cast<QValidator*>(validator));
}

void QComboBox_SetView(void* ptr, void* itemView)
{
	static_cast<QComboBox*>(ptr)->setView(static_cast<QAbstractItemView*>(itemView));
}

void QComboBox_ShowPopup(void* ptr)
{
	static_cast<QComboBox*>(ptr)->showPopup();
}

void QComboBox_ShowPopupDefault(void* ptr)
{
	if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::showPopup();
	} else {
		static_cast<QComboBox*>(ptr)->QComboBox::showPopup();
	}
}

long long QComboBox_SizeAdjustPolicy(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->sizeAdjustPolicy();
}

void* QComboBox_Validator(void* ptr)
{
	return const_cast<QValidator*>(static_cast<QComboBox*>(ptr)->validator());
}

void* QComboBox_View(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->view();
}

void QComboBox_DestroyQComboBox(void* ptr)
{
	static_cast<QComboBox*>(ptr)->~QComboBox();
}

void QComboBox_DestroyQComboBoxDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQCommandLinkButton: public QCommandLinkButton
{
public:
	MyQCommandLinkButton(QWidget *parent = Q_NULLPTR) : QCommandLinkButton(parent) {QCommandLinkButton_QCommandLinkButton_QRegisterMetaType();};
	MyQCommandLinkButton(const QString &text, QWidget *parent = Q_NULLPTR) : QCommandLinkButton(text, parent) {QCommandLinkButton_QCommandLinkButton_QRegisterMetaType();};
	MyQCommandLinkButton(const QString &text, const QString &description, QWidget *parent = Q_NULLPTR) : QCommandLinkButton(text, description, parent) {QCommandLinkButton_QCommandLinkButton_QRegisterMetaType();};
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	int heightForWidth(int width) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), width); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * vqp) { callbackQPushButton_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQCommandLinkButton() { callbackQCommandLinkButton_DestroyQCommandLinkButton(this); };
	void focusInEvent(QFocusEvent * e) { callbackQWidget_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQWidget_FocusOutEvent(this, e); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void showMenu() { callbackQPushButton_ShowMenu(this); };
	void animateClick(int msec) { callbackQAbstractButton_AnimateClick(this, msec); };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void checkStateSet() { callbackQAbstractButton_CheckStateSet(this); };
	void click() { callbackQAbstractButton_Click(this); };
	void Signal_Clicked(bool checked) { callbackQAbstractButton_Clicked(this, checked); };
	bool hitButton(const QPoint & pos) const { return callbackQAbstractButton_HitButton(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&pos)) != 0; };
	void keyReleaseEvent(QKeyEvent * e) { callbackQWidget_KeyReleaseEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void nextCheckState() { callbackQAbstractButton_NextCheckState(this); };
	void Signal_Pressed() { callbackQAbstractButton_Pressed(this); };
	void Signal_Released() { callbackQAbstractButton_Released(this); };
	void setChecked(bool vbo) { callbackQAbstractButton_SetChecked(this, vbo); };
	void setIconSize(const QSize & size) { callbackQAbstractButton_SetIconSize(this, const_cast<QSize*>(&size)); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void toggle() { callbackQAbstractButton_Toggle(this); };
	void Signal_Toggled(bool checked) { callbackQAbstractButton_Toggled(this, checked); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QCommandLinkButton*)
Q_DECLARE_METATYPE(MyQCommandLinkButton*)

int QCommandLinkButton_QCommandLinkButton_QRegisterMetaType(){qRegisterMetaType<QCommandLinkButton*>(); return qRegisterMetaType<MyQCommandLinkButton*>();}

void* QCommandLinkButton_NewQCommandLinkButton(void* parent)
{
		return new MyQCommandLinkButton(static_cast<QWidget*>(parent));
}

void* QCommandLinkButton_NewQCommandLinkButton2(struct QtWidgets_PackedString text, void* parent)
{
		return new MyQCommandLinkButton(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(parent));
}

void* QCommandLinkButton_NewQCommandLinkButton3(struct QtWidgets_PackedString text, struct QtWidgets_PackedString description, void* parent)
{
		return new MyQCommandLinkButton(QString::fromUtf8(text.data, text.len), QString::fromUtf8(description.data, description.len), static_cast<QWidget*>(parent));
}

struct QtWidgets_PackedString QCommandLinkButton_Description(void* ptr)
{
	return ({ QByteArray* t0a86ba = new QByteArray(static_cast<QCommandLinkButton*>(ptr)->description().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t0a86ba->prepend("WHITESPACE").constData()+10), t0a86ba->size()-10, t0a86ba }; });
}

void QCommandLinkButton_SetDescription(void* ptr, struct QtWidgets_PackedString description)
{
	static_cast<QCommandLinkButton*>(ptr)->setDescription(QString::fromUtf8(description.data, description.len));
}

void QCommandLinkButton_DestroyQCommandLinkButton(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->~QCommandLinkButton();
}

void QCommandLinkButton_DestroyQCommandLinkButtonDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQCommonStyle: public QCommonStyle
{
public:
	MyQCommonStyle() : QCommonStyle() {QCommonStyle_QCommonStyle_QRegisterMetaType();};
	void drawComplexControl(QStyle::ComplexControl cc, const QStyleOptionComplex * opt, QPainter * p, const QWidget * widget) const { callbackQCommonStyle_DrawComplexControl(const_cast<void*>(static_cast<const void*>(this)), cc, const_cast<QStyleOptionComplex*>(opt), p, const_cast<QWidget*>(widget)); };
	void drawControl(QStyle::ControlElement element, const QStyleOption * opt, QPainter * p, const QWidget * widget) const { callbackQCommonStyle_DrawControl(const_cast<void*>(static_cast<const void*>(this)), element, const_cast<QStyleOption*>(opt), p, const_cast<QWidget*>(widget)); };
	void drawPrimitive(QStyle::PrimitiveElement pe, const QStyleOption * opt, QPainter * p, const QWidget * widget) const { callbackQCommonStyle_DrawPrimitive(const_cast<void*>(static_cast<const void*>(this)), pe, const_cast<QStyleOption*>(opt), p, const_cast<QWidget*>(widget)); };
	QPixmap generatedIconPixmap(QIcon::Mode iconMode, const QPixmap & pixmap, const QStyleOption * opt) const { return *static_cast<QPixmap*>(callbackQCommonStyle_GeneratedIconPixmap(const_cast<void*>(static_cast<const void*>(this)), iconMode, const_cast<QPixmap*>(&pixmap), const_cast<QStyleOption*>(opt))); };
	QStyle::SubControl hitTestComplexControl(QStyle::ComplexControl cc, const QStyleOptionComplex * opt, const QPoint & pt, const QWidget * widget) const { return static_cast<QStyle::SubControl>(callbackQCommonStyle_HitTestComplexControl(const_cast<void*>(static_cast<const void*>(this)), cc, const_cast<QStyleOptionComplex*>(opt), const_cast<QPoint*>(&pt), const_cast<QWidget*>(widget))); };
	int layoutSpacing(QSizePolicy::ControlType control1, QSizePolicy::ControlType control2, Qt::Orientation orientation, const QStyleOption * option, const QWidget * widget) const { return callbackQCommonStyle_LayoutSpacing(const_cast<void*>(static_cast<const void*>(this)), control1, control2, orientation, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget)); };
	int pixelMetric(QStyle::PixelMetric m, const QStyleOption * opt, const QWidget * widget) const { return callbackQCommonStyle_PixelMetric(const_cast<void*>(static_cast<const void*>(this)), m, const_cast<QStyleOption*>(opt), const_cast<QWidget*>(widget)); };
	void polish(QPalette & pal) { callbackQStyle_Polish(this, static_cast<QPalette*>(&pal)); };
	void polish(QApplication * app) { callbackQStyle_Polish2(this, app); };
	void polish(QWidget * widget) { callbackQStyle_Polish3(this, widget); };
	QSize sizeFromContents(QStyle::ContentsType ct, const QStyleOption * opt, const QSize & csz, const QWidget * widget) const { return *static_cast<QSize*>(callbackQCommonStyle_SizeFromContents(const_cast<void*>(static_cast<const void*>(this)), ct, const_cast<QStyleOption*>(opt), const_cast<QSize*>(&csz), const_cast<QWidget*>(widget))); };
	QPixmap standardPixmap(QStyle::StandardPixmap sp, const QStyleOption * option, const QWidget * widget) const { return *static_cast<QPixmap*>(callbackQCommonStyle_StandardPixmap(const_cast<void*>(static_cast<const void*>(this)), sp, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
	int styleHint(QStyle::StyleHint sh, const QStyleOption * opt, const QWidget * widget, QStyleHintReturn * hret) const { return callbackQCommonStyle_StyleHint(const_cast<void*>(static_cast<const void*>(this)), sh, const_cast<QStyleOption*>(opt), const_cast<QWidget*>(widget), hret); };
	QRect subControlRect(QStyle::ComplexControl cc, const QStyleOptionComplex * opt, QStyle::SubControl sc, const QWidget * widget) const { return *static_cast<QRect*>(callbackQCommonStyle_SubControlRect(const_cast<void*>(static_cast<const void*>(this)), cc, const_cast<QStyleOptionComplex*>(opt), sc, const_cast<QWidget*>(widget))); };
	QRect subElementRect(QStyle::SubElement sr, const QStyleOption * opt, const QWidget * widget) const { return *static_cast<QRect*>(callbackQCommonStyle_SubElementRect(const_cast<void*>(static_cast<const void*>(this)), sr, const_cast<QStyleOption*>(opt), const_cast<QWidget*>(widget))); };
	void unpolish(QWidget * widget) { callbackQStyle_Unpolish(this, widget); };
	void unpolish(QApplication * application) { callbackQStyle_Unpolish2(this, application); };
	 ~MyQCommonStyle() { callbackQCommonStyle_DestroyQCommonStyle(this); };
	void drawItemPixmap(QPainter * painter, const QRect & rectangle, int alignment, const QPixmap & pixmap) const { callbackQStyle_DrawItemPixmap(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QRect*>(&rectangle), alignment, const_cast<QPixmap*>(&pixmap)); };
	void drawItemText(QPainter * painter, const QRect & rectangle, int alignment, const QPalette & palette, bool enabled, const QString & text, QPalette::ColorRole textRole) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQStyle_DrawItemText(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QRect*>(&rectangle), alignment, const_cast<QPalette*>(&palette), enabled, textPacked, textRole); };
	QRect itemPixmapRect(const QRect & rectangle, int alignment, const QPixmap & pixmap) const { return *static_cast<QRect*>(callbackQStyle_ItemPixmapRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QRect*>(&rectangle), alignment, const_cast<QPixmap*>(&pixmap))); };
	QRect itemTextRect(const QFontMetrics & metrics, const QRect & rectangle, int alignment, bool enabled, const QString & text) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };return *static_cast<QRect*>(callbackQStyle_ItemTextRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QFontMetrics*>(&metrics), const_cast<QRect*>(&rectangle), alignment, enabled, textPacked)); };
	QIcon standardIcon(QStyle::StandardPixmap standardIcon, const QStyleOption * option, const QWidget * widget) const { return *static_cast<QIcon*>(callbackQCommonStyle_StandardIcon(const_cast<void*>(static_cast<const void*>(this)), standardIcon, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
	QPalette standardPalette() const { return *static_cast<QPalette*>(callbackQStyle_StandardPalette(const_cast<void*>(static_cast<const void*>(this)))); };
	void childEvent(QChildEvent * event) { callbackQStyle_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQStyle_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQStyle_CustomEvent(this, event); };
	void deleteLater() { callbackQStyle_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQStyle_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQStyle_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQStyle_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQStyle_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStyle_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQStyle_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQStyle_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCommonStyle*)
Q_DECLARE_METATYPE(MyQCommonStyle*)

int QCommonStyle_QCommonStyle_QRegisterMetaType(){qRegisterMetaType<QCommonStyle*>(); return qRegisterMetaType<MyQCommonStyle*>();}

void* QCommonStyle_NewQCommonStyle()
{
	return new MyQCommonStyle();
}

void QCommonStyle_DrawComplexControl(void* ptr, long long cc, void* opt, void* p, void* widget)
{
		static_cast<QCommonStyle*>(ptr)->drawComplexControl(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QPainter*>(p), static_cast<QWidget*>(widget));
}

void QCommonStyle_DrawComplexControlDefault(void* ptr, long long cc, void* opt, void* p, void* widget)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::drawComplexControl(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QPainter*>(p), static_cast<QWidget*>(widget));
	} else {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::drawComplexControl(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QPainter*>(p), static_cast<QWidget*>(widget));
	}
}

void QCommonStyle_DrawControl(void* ptr, long long element, void* opt, void* p, void* widget)
{
		static_cast<QCommonStyle*>(ptr)->drawControl(static_cast<QStyle::ControlElement>(element), static_cast<QStyleOption*>(opt), static_cast<QPainter*>(p), static_cast<QWidget*>(widget));
}

void QCommonStyle_DrawControlDefault(void* ptr, long long element, void* opt, void* p, void* widget)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::drawControl(static_cast<QStyle::ControlElement>(element), static_cast<QStyleOption*>(opt), static_cast<QPainter*>(p), static_cast<QWidget*>(widget));
	} else {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::drawControl(static_cast<QStyle::ControlElement>(element), static_cast<QStyleOption*>(opt), static_cast<QPainter*>(p), static_cast<QWidget*>(widget));
	}
}

void QCommonStyle_DrawPrimitive(void* ptr, long long pe, void* opt, void* p, void* widget)
{
		static_cast<QCommonStyle*>(ptr)->drawPrimitive(static_cast<QStyle::PrimitiveElement>(pe), static_cast<QStyleOption*>(opt), static_cast<QPainter*>(p), static_cast<QWidget*>(widget));
}

void QCommonStyle_DrawPrimitiveDefault(void* ptr, long long pe, void* opt, void* p, void* widget)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::drawPrimitive(static_cast<QStyle::PrimitiveElement>(pe), static_cast<QStyleOption*>(opt), static_cast<QPainter*>(p), static_cast<QWidget*>(widget));
	} else {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::drawPrimitive(static_cast<QStyle::PrimitiveElement>(pe), static_cast<QStyleOption*>(opt), static_cast<QPainter*>(p), static_cast<QWidget*>(widget));
	}
}

void* QCommonStyle_GeneratedIconPixmap(void* ptr, long long iconMode, void* pixmap, void* opt)
{
	return new QPixmap(static_cast<QCommonStyle*>(ptr)->generatedIconPixmap(static_cast<QIcon::Mode>(iconMode), *static_cast<QPixmap*>(pixmap), static_cast<QStyleOption*>(opt)));
}

void* QCommonStyle_GeneratedIconPixmapDefault(void* ptr, long long iconMode, void* pixmap, void* opt)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return new QPixmap(static_cast<QProxyStyle*>(ptr)->QProxyStyle::generatedIconPixmap(static_cast<QIcon::Mode>(iconMode), *static_cast<QPixmap*>(pixmap), static_cast<QStyleOption*>(opt)));
	} else {
		return new QPixmap(static_cast<QCommonStyle*>(ptr)->QCommonStyle::generatedIconPixmap(static_cast<QIcon::Mode>(iconMode), *static_cast<QPixmap*>(pixmap), static_cast<QStyleOption*>(opt)));
	}
}

long long QCommonStyle_HitTestComplexControl(void* ptr, long long cc, void* opt, void* pt, void* widget)
{
		return static_cast<QCommonStyle*>(ptr)->hitTestComplexControl(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), *static_cast<QPoint*>(pt), static_cast<QWidget*>(widget));
}

long long QCommonStyle_HitTestComplexControlDefault(void* ptr, long long cc, void* opt, void* pt, void* widget)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProxyStyle*>(ptr)->QProxyStyle::hitTestComplexControl(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), *static_cast<QPoint*>(pt), static_cast<QWidget*>(widget));
	} else {
		return static_cast<QCommonStyle*>(ptr)->QCommonStyle::hitTestComplexControl(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), *static_cast<QPoint*>(pt), static_cast<QWidget*>(widget));
	}
}

int QCommonStyle_LayoutSpacing(void* ptr, long long control1, long long control2, long long orientation, void* option, void* widget)
{
		return static_cast<QCommonStyle*>(ptr)->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget));
}

int QCommonStyle_LayoutSpacingDefault(void* ptr, long long control1, long long control2, long long orientation, void* option, void* widget)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProxyStyle*>(ptr)->QProxyStyle::layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget));
	} else {
		return static_cast<QCommonStyle*>(ptr)->QCommonStyle::layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget));
	}
}

int QCommonStyle_PixelMetric(void* ptr, long long m, void* opt, void* widget)
{
		return static_cast<QCommonStyle*>(ptr)->pixelMetric(static_cast<QStyle::PixelMetric>(m), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget));
}

int QCommonStyle_PixelMetricDefault(void* ptr, long long m, void* opt, void* widget)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProxyStyle*>(ptr)->QProxyStyle::pixelMetric(static_cast<QStyle::PixelMetric>(m), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget));
	} else {
		return static_cast<QCommonStyle*>(ptr)->QCommonStyle::pixelMetric(static_cast<QStyle::PixelMetric>(m), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget));
	}
}

void* QCommonStyle_SizeFromContents(void* ptr, long long ct, void* opt, void* csz, void* widget)
{
		return ({ QSize tmpValue = static_cast<QCommonStyle*>(ptr)->sizeFromContents(static_cast<QStyle::ContentsType>(ct), static_cast<QStyleOption*>(opt), *static_cast<QSize*>(csz), static_cast<QWidget*>(widget)); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QCommonStyle_SizeFromContentsDefault(void* ptr, long long ct, void* opt, void* csz, void* widget)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QProxyStyle*>(ptr)->QProxyStyle::sizeFromContents(static_cast<QStyle::ContentsType>(ct), static_cast<QStyleOption*>(opt), *static_cast<QSize*>(csz), static_cast<QWidget*>(widget)); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QCommonStyle*>(ptr)->QCommonStyle::sizeFromContents(static_cast<QStyle::ContentsType>(ct), static_cast<QStyleOption*>(opt), *static_cast<QSize*>(csz), static_cast<QWidget*>(widget)); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void* QCommonStyle_StandardPixmap(void* ptr, long long sp, void* option, void* widget)
{
		return new QPixmap(static_cast<QCommonStyle*>(ptr)->standardPixmap(static_cast<QStyle::StandardPixmap>(sp), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget)));
}

void* QCommonStyle_StandardPixmapDefault(void* ptr, long long sp, void* option, void* widget)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return new QPixmap(static_cast<QProxyStyle*>(ptr)->QProxyStyle::standardPixmap(static_cast<QStyle::StandardPixmap>(sp), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget)));
	} else {
		return new QPixmap(static_cast<QCommonStyle*>(ptr)->QCommonStyle::standardPixmap(static_cast<QStyle::StandardPixmap>(sp), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget)));
	}
}

int QCommonStyle_StyleHint(void* ptr, long long sh, void* opt, void* widget, void* hret)
{
		return static_cast<QCommonStyle*>(ptr)->styleHint(static_cast<QStyle::StyleHint>(sh), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget), static_cast<QStyleHintReturn*>(hret));
}

int QCommonStyle_StyleHintDefault(void* ptr, long long sh, void* opt, void* widget, void* hret)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProxyStyle*>(ptr)->QProxyStyle::styleHint(static_cast<QStyle::StyleHint>(sh), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget), static_cast<QStyleHintReturn*>(hret));
	} else {
		return static_cast<QCommonStyle*>(ptr)->QCommonStyle::styleHint(static_cast<QStyle::StyleHint>(sh), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget), static_cast<QStyleHintReturn*>(hret));
	}
}

void* QCommonStyle_SubControlRect(void* ptr, long long cc, void* opt, long long sc, void* widget)
{
		return ({ QRect tmpValue = static_cast<QCommonStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QCommonStyle_SubControlRectDefault(void* ptr, long long cc, void* opt, long long sc, void* widget)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QProxyStyle*>(ptr)->QProxyStyle::subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRect tmpValue = static_cast<QCommonStyle*>(ptr)->QCommonStyle::subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QCommonStyle_SubElementRect(void* ptr, long long sr, void* opt, void* widget)
{
		return ({ QRect tmpValue = static_cast<QCommonStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(sr), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QCommonStyle_SubElementRectDefault(void* ptr, long long sr, void* opt, void* widget)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QProxyStyle*>(ptr)->QProxyStyle::subElementRect(static_cast<QStyle::SubElement>(sr), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRect tmpValue = static_cast<QCommonStyle*>(ptr)->QCommonStyle::subElementRect(static_cast<QStyle::SubElement>(sr), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void QCommonStyle_DestroyQCommonStyle(void* ptr)
{
	static_cast<QCommonStyle*>(ptr)->~QCommonStyle();
}

void QCommonStyle_DestroyQCommonStyleDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QCommonStyle_StandardIcon(void* ptr, long long standardIcon, void* option, void* widget)
{
		return new QIcon(static_cast<QCommonStyle*>(ptr)->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget)));
}

void* QCommonStyle_StandardIconDefault(void* ptr, long long standardIcon, void* option, void* widget)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return new QIcon(static_cast<QProxyStyle*>(ptr)->QProxyStyle::standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget)));
	} else {
		return new QIcon(static_cast<QCommonStyle*>(ptr)->QCommonStyle::standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget)));
	}
}

class MyQCompleter: public QCompleter
{
public:
	MyQCompleter(QObject *parent = Q_NULLPTR) : QCompleter(parent) {QCompleter_QCompleter_QRegisterMetaType();};
	MyQCompleter(QAbstractItemModel *model, QObject *parent = Q_NULLPTR) : QCompleter(model, parent) {QCompleter_QCompleter_QRegisterMetaType();};
	MyQCompleter(const QStringList &list, QObject *parent = Q_NULLPTR) : QCompleter(list, parent) {QCompleter_QCompleter_QRegisterMetaType();};
	void Signal_Activated(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQCompleter_Activated(this, textPacked); };
	void Signal_Activated2(const QModelIndex & index) { callbackQCompleter_Activated2(this, const_cast<QModelIndex*>(&index)); };
	void complete(const QRect & rect) { callbackQCompleter_Complete(this, const_cast<QRect*>(&rect)); };
	bool event(QEvent * ev) { return callbackQCompleter_Event(this, ev) != 0; };
	bool eventFilter(QObject * o, QEvent * e) { return callbackQCompleter_EventFilter(this, o, e) != 0; };
	void Signal_Highlighted(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQCompleter_Highlighted(this, textPacked); };
	void Signal_Highlighted2(const QModelIndex & index) { callbackQCompleter_Highlighted2(this, const_cast<QModelIndex*>(&index)); };
	QString pathFromIndex(const QModelIndex & index) const { return ({ QtWidgets_PackedString tempVal = callbackQCompleter_PathFromIndex(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index)); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void setCompletionPrefix(const QString & prefix) { QByteArray* tb4ebfe = new QByteArray(prefix.toUtf8()); QtWidgets_PackedString prefixPacked = { const_cast<char*>(tb4ebfe->prepend("WHITESPACE").constData()+10), tb4ebfe->size()-10, tb4ebfe };callbackQCompleter_SetCompletionPrefix(this, prefixPacked); };
	void setWrapAround(bool wrap) { callbackQCompleter_SetWrapAround(this, wrap); };
	QStringList splitPath(const QString & path) const { QByteArray* t3150ec = new QByteArray(path.toUtf8()); QtWidgets_PackedString pathPacked = { const_cast<char*>(t3150ec->prepend("WHITESPACE").constData()+10), t3150ec->size()-10, t3150ec };return ({ QtWidgets_PackedString tempVal = callbackQCompleter_SplitPath(const_cast<void*>(static_cast<const void*>(this)), pathPacked); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	 ~MyQCompleter() { callbackQCompleter_DestroyQCompleter(this); };
	void childEvent(QChildEvent * event) { callbackQCompleter_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQCompleter_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQCompleter_CustomEvent(this, event); };
	void deleteLater() { callbackQCompleter_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQCompleter_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQCompleter_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCompleter_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQCompleter_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQCompleter_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QCompleter*)
Q_DECLARE_METATYPE(MyQCompleter*)

int QCompleter_QCompleter_QRegisterMetaType(){qRegisterMetaType<QCompleter*>(); return qRegisterMetaType<MyQCompleter*>();}

void* QCompleter_NewQCompleter(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QWindow*>(parent));
	} else {
		return new MyQCompleter(static_cast<QObject*>(parent));
	}
}

void* QCompleter_NewQCompleter2(void* model, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QWindow*>(parent));
	} else {
		return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QObject*>(parent));
	}
}

void* QCompleter_NewQCompleter3(struct QtWidgets_PackedString list, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QWindow*>(parent));
	} else {
		return new MyQCompleter(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QObject*>(parent));
	}
}

void QCompleter_ConnectActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QCompleter*>(ptr), static_cast<void (QCompleter::*)(const QString &)>(&QCompleter::activated), static_cast<MyQCompleter*>(ptr), static_cast<void (MyQCompleter::*)(const QString &)>(&MyQCompleter::Signal_Activated), static_cast<Qt::ConnectionType>(t));
}

void QCompleter_DisconnectActivated(void* ptr)
{
	QObject::disconnect(static_cast<QCompleter*>(ptr), static_cast<void (QCompleter::*)(const QString &)>(&QCompleter::activated), static_cast<MyQCompleter*>(ptr), static_cast<void (MyQCompleter::*)(const QString &)>(&MyQCompleter::Signal_Activated));
}

void QCompleter_Activated(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QCompleter*>(ptr)->activated(QString::fromUtf8(text.data, text.len));
}

void QCompleter_ConnectActivated2(void* ptr, long long t)
{
	QObject::connect(static_cast<QCompleter*>(ptr), static_cast<void (QCompleter::*)(const QModelIndex &)>(&QCompleter::activated), static_cast<MyQCompleter*>(ptr), static_cast<void (MyQCompleter::*)(const QModelIndex &)>(&MyQCompleter::Signal_Activated2), static_cast<Qt::ConnectionType>(t));
}

void QCompleter_DisconnectActivated2(void* ptr)
{
	QObject::disconnect(static_cast<QCompleter*>(ptr), static_cast<void (QCompleter::*)(const QModelIndex &)>(&QCompleter::activated), static_cast<MyQCompleter*>(ptr), static_cast<void (MyQCompleter::*)(const QModelIndex &)>(&MyQCompleter::Signal_Activated2));
}

void QCompleter_Activated2(void* ptr, void* index)
{
	static_cast<QCompleter*>(ptr)->activated(*static_cast<QModelIndex*>(index));
}

long long QCompleter_CaseSensitivity(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->caseSensitivity();
}

void QCompleter_Complete(void* ptr, void* rect)
{
	QMetaObject::invokeMethod(static_cast<QCompleter*>(ptr), "complete", Q_ARG(const QRect, *static_cast<QRect*>(rect)));
}

void QCompleter_CompleteDefault(void* ptr, void* rect)
{
		static_cast<QCompleter*>(ptr)->QCompleter::complete(*static_cast<QRect*>(rect));
}

int QCompleter_CompletionColumn(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->completionColumn();
}

int QCompleter_CompletionCount(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->completionCount();
}

long long QCompleter_CompletionMode(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->completionMode();
}

void* QCompleter_CompletionModel(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->completionModel();
}

struct QtWidgets_PackedString QCompleter_CompletionPrefix(void* ptr)
{
	return ({ QByteArray* t26112f = new QByteArray(static_cast<QCompleter*>(ptr)->completionPrefix().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t26112f->prepend("WHITESPACE").constData()+10), t26112f->size()-10, t26112f }; });
}

int QCompleter_CompletionRole(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->completionRole();
}

struct QtWidgets_PackedString QCompleter_CurrentCompletion(void* ptr)
{
	return ({ QByteArray* t7ce42a = new QByteArray(static_cast<QCompleter*>(ptr)->currentCompletion().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t7ce42a->prepend("WHITESPACE").constData()+10), t7ce42a->size()-10, t7ce42a }; });
}

void* QCompleter_CurrentIndex(void* ptr)
{
	return new QModelIndex(static_cast<QCompleter*>(ptr)->currentIndex());
}

int QCompleter_CurrentRow(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->currentRow();
}

char QCompleter_EventDefault(void* ptr, void* ev)
{
		return static_cast<QCompleter*>(ptr)->QCompleter::event(static_cast<QEvent*>(ev));
}

char QCompleter_EventFilterDefault(void* ptr, void* o, void* e)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(o))) {
		return static_cast<QCompleter*>(ptr)->QCompleter::eventFilter(static_cast<QGraphicsObject*>(o), static_cast<QEvent*>(e));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(o))) {
		return static_cast<QCompleter*>(ptr)->QCompleter::eventFilter(static_cast<QGraphicsWidget*>(o), static_cast<QEvent*>(e));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(o))) {
		return static_cast<QCompleter*>(ptr)->QCompleter::eventFilter(static_cast<QLayout*>(o), static_cast<QEvent*>(e));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(o))) {
		return static_cast<QCompleter*>(ptr)->QCompleter::eventFilter(static_cast<QWidget*>(o), static_cast<QEvent*>(e));
	} else {
		return static_cast<QCompleter*>(ptr)->QCompleter::eventFilter(static_cast<QObject*>(o), static_cast<QEvent*>(e));
	}
}

long long QCompleter_FilterMode(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->filterMode();
}

void QCompleter_ConnectHighlighted(void* ptr, long long t)
{
	QObject::connect(static_cast<QCompleter*>(ptr), static_cast<void (QCompleter::*)(const QString &)>(&QCompleter::highlighted), static_cast<MyQCompleter*>(ptr), static_cast<void (MyQCompleter::*)(const QString &)>(&MyQCompleter::Signal_Highlighted), static_cast<Qt::ConnectionType>(t));
}

void QCompleter_DisconnectHighlighted(void* ptr)
{
	QObject::disconnect(static_cast<QCompleter*>(ptr), static_cast<void (QCompleter::*)(const QString &)>(&QCompleter::highlighted), static_cast<MyQCompleter*>(ptr), static_cast<void (MyQCompleter::*)(const QString &)>(&MyQCompleter::Signal_Highlighted));
}

void QCompleter_Highlighted(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QCompleter*>(ptr)->highlighted(QString::fromUtf8(text.data, text.len));
}

void QCompleter_ConnectHighlighted2(void* ptr, long long t)
{
	QObject::connect(static_cast<QCompleter*>(ptr), static_cast<void (QCompleter::*)(const QModelIndex &)>(&QCompleter::highlighted), static_cast<MyQCompleter*>(ptr), static_cast<void (MyQCompleter::*)(const QModelIndex &)>(&MyQCompleter::Signal_Highlighted2), static_cast<Qt::ConnectionType>(t));
}

void QCompleter_DisconnectHighlighted2(void* ptr)
{
	QObject::disconnect(static_cast<QCompleter*>(ptr), static_cast<void (QCompleter::*)(const QModelIndex &)>(&QCompleter::highlighted), static_cast<MyQCompleter*>(ptr), static_cast<void (MyQCompleter::*)(const QModelIndex &)>(&MyQCompleter::Signal_Highlighted2));
}

void QCompleter_Highlighted2(void* ptr, void* index)
{
	static_cast<QCompleter*>(ptr)->highlighted(*static_cast<QModelIndex*>(index));
}

int QCompleter_MaxVisibleItems(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->maxVisibleItems();
}

void* QCompleter_Model(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->model();
}

long long QCompleter_ModelSorting(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->modelSorting();
}

struct QtWidgets_PackedString QCompleter_PathFromIndex(void* ptr, void* index)
{
	return ({ QByteArray* t37a887 = new QByteArray(static_cast<QCompleter*>(ptr)->pathFromIndex(*static_cast<QModelIndex*>(index)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t37a887->prepend("WHITESPACE").constData()+10), t37a887->size()-10, t37a887 }; });
}

struct QtWidgets_PackedString QCompleter_PathFromIndexDefault(void* ptr, void* index)
{
		return ({ QByteArray* td0fb01 = new QByteArray(static_cast<QCompleter*>(ptr)->QCompleter::pathFromIndex(*static_cast<QModelIndex*>(index)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(td0fb01->prepend("WHITESPACE").constData()+10), td0fb01->size()-10, td0fb01 }; });
}

void* QCompleter_Popup(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->popup();
}

void QCompleter_SetCaseSensitivity(void* ptr, long long caseSensitivity)
{
	static_cast<QCompleter*>(ptr)->setCaseSensitivity(static_cast<Qt::CaseSensitivity>(caseSensitivity));
}

void QCompleter_SetCompletionColumn(void* ptr, int column)
{
	static_cast<QCompleter*>(ptr)->setCompletionColumn(column);
}

void QCompleter_SetCompletionMode(void* ptr, long long mode)
{
	static_cast<QCompleter*>(ptr)->setCompletionMode(static_cast<QCompleter::CompletionMode>(mode));
}

void QCompleter_SetCompletionPrefix(void* ptr, struct QtWidgets_PackedString prefix)
{
	QMetaObject::invokeMethod(static_cast<QCompleter*>(ptr), "setCompletionPrefix", Q_ARG(const QString, QString::fromUtf8(prefix.data, prefix.len)));
}

void QCompleter_SetCompletionPrefixDefault(void* ptr, struct QtWidgets_PackedString prefix)
{
		static_cast<QCompleter*>(ptr)->QCompleter::setCompletionPrefix(QString::fromUtf8(prefix.data, prefix.len));
}

void QCompleter_SetCompletionRole(void* ptr, int role)
{
	static_cast<QCompleter*>(ptr)->setCompletionRole(role);
}

char QCompleter_SetCurrentRow(void* ptr, int row)
{
	return static_cast<QCompleter*>(ptr)->setCurrentRow(row);
}

void QCompleter_SetFilterMode(void* ptr, long long filterMode)
{
	static_cast<QCompleter*>(ptr)->setFilterMode(static_cast<Qt::MatchFlag>(filterMode));
}

void QCompleter_SetMaxVisibleItems(void* ptr, int maxItems)
{
	static_cast<QCompleter*>(ptr)->setMaxVisibleItems(maxItems);
}

void QCompleter_SetModel(void* ptr, void* model)
{
	static_cast<QCompleter*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}

void QCompleter_SetModelSorting(void* ptr, long long sorting)
{
	static_cast<QCompleter*>(ptr)->setModelSorting(static_cast<QCompleter::ModelSorting>(sorting));
}

void QCompleter_SetPopup(void* ptr, void* popup)
{
	static_cast<QCompleter*>(ptr)->setPopup(static_cast<QAbstractItemView*>(popup));
}

void QCompleter_SetWidget(void* ptr, void* widget)
{
		static_cast<QCompleter*>(ptr)->setWidget(static_cast<QWidget*>(widget));
}

void QCompleter_SetWrapAround(void* ptr, char wrap)
{
	QMetaObject::invokeMethod(static_cast<QCompleter*>(ptr), "setWrapAround", Q_ARG(bool, wrap != 0));
}

void QCompleter_SetWrapAroundDefault(void* ptr, char wrap)
{
		static_cast<QCompleter*>(ptr)->QCompleter::setWrapAround(wrap != 0);
}

struct QtWidgets_PackedString QCompleter_SplitPath(void* ptr, struct QtWidgets_PackedString path)
{
	return ({ QByteArray* t40101c = new QByteArray(static_cast<QCompleter*>(ptr)->splitPath(QString::fromUtf8(path.data, path.len)).join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t40101c->prepend("WHITESPACE").constData()+10), t40101c->size()-10, t40101c }; });
}

struct QtWidgets_PackedString QCompleter_SplitPathDefault(void* ptr, struct QtWidgets_PackedString path)
{
		return ({ QByteArray* tdf319d = new QByteArray(static_cast<QCompleter*>(ptr)->QCompleter::splitPath(QString::fromUtf8(path.data, path.len)).join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(tdf319d->prepend("WHITESPACE").constData()+10), tdf319d->size()-10, tdf319d }; });
}

void* QCompleter_Widget(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->widget();
}

char QCompleter_WrapAround(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->wrapAround();
}

void QCompleter_DestroyQCompleter(void* ptr)
{
	static_cast<QCompleter*>(ptr)->~QCompleter();
}

void QCompleter_DestroyQCompleterDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QCompleter___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCompleter___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QCompleter___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QCompleter___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCompleter___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QCompleter___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QCompleter___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

void QCompleter_DeleteLaterDefault(void* ptr)
{
		static_cast<QCompleter*>(ptr)->QCompleter::deleteLater();
}

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

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

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

class MyQDataWidgetMapper: public QDataWidgetMapper
{
public:
	MyQDataWidgetMapper(QObject *parent = Q_NULLPTR) : QDataWidgetMapper(parent) {QDataWidgetMapper_QDataWidgetMapper_QRegisterMetaType();};
	void Signal_CurrentIndexChanged(int index) { callbackQDataWidgetMapper_CurrentIndexChanged(this, index); };
	void revert() { callbackQDataWidgetMapper_Revert(this); };
	void setCurrentIndex(int index) { callbackQDataWidgetMapper_SetCurrentIndex(this, index); };
	void setCurrentModelIndex(const QModelIndex & index) { callbackQDataWidgetMapper_SetCurrentModelIndex(this, const_cast<QModelIndex*>(&index)); };
	bool submit() { return callbackQDataWidgetMapper_Submit(this) != 0; };
	void toFirst() { callbackQDataWidgetMapper_ToFirst(this); };
	void toLast() { callbackQDataWidgetMapper_ToLast(this); };
	void toNext() { callbackQDataWidgetMapper_ToNext(this); };
	void toPrevious() { callbackQDataWidgetMapper_ToPrevious(this); };
	 ~MyQDataWidgetMapper() { callbackQDataWidgetMapper_DestroyQDataWidgetMapper(this); };
	void childEvent(QChildEvent * event) { callbackQDataWidgetMapper_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQDataWidgetMapper_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQDataWidgetMapper_CustomEvent(this, event); };
	void deleteLater() { callbackQDataWidgetMapper_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQDataWidgetMapper_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQDataWidgetMapper_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQDataWidgetMapper_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQDataWidgetMapper_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDataWidgetMapper_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQDataWidgetMapper_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQDataWidgetMapper_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QDataWidgetMapper*)
Q_DECLARE_METATYPE(MyQDataWidgetMapper*)

int QDataWidgetMapper_QDataWidgetMapper_QRegisterMetaType(){qRegisterMetaType<QDataWidgetMapper*>(); return qRegisterMetaType<MyQDataWidgetMapper*>();}

void* QDataWidgetMapper_NewQDataWidgetMapper(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQDataWidgetMapper(static_cast<QWindow*>(parent));
	} else {
		return new MyQDataWidgetMapper(static_cast<QObject*>(parent));
	}
}

void QDataWidgetMapper_AddMapping(void* ptr, void* widget, int section)
{
		static_cast<QDataWidgetMapper*>(ptr)->addMapping(static_cast<QWidget*>(widget), section);
}

void QDataWidgetMapper_AddMapping2(void* ptr, void* widget, int section, void* propertyName)
{
		static_cast<QDataWidgetMapper*>(ptr)->addMapping(static_cast<QWidget*>(widget), section, *static_cast<QByteArray*>(propertyName));
}

void QDataWidgetMapper_ClearMapping(void* ptr)
{
	static_cast<QDataWidgetMapper*>(ptr)->clearMapping();
}

int QDataWidgetMapper_CurrentIndex(void* ptr)
{
	return static_cast<QDataWidgetMapper*>(ptr)->currentIndex();
}

void QDataWidgetMapper_ConnectCurrentIndexChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QDataWidgetMapper*>(ptr), static_cast<void (QDataWidgetMapper::*)(int)>(&QDataWidgetMapper::currentIndexChanged), static_cast<MyQDataWidgetMapper*>(ptr), static_cast<void (MyQDataWidgetMapper::*)(int)>(&MyQDataWidgetMapper::Signal_CurrentIndexChanged), static_cast<Qt::ConnectionType>(t));
}

void QDataWidgetMapper_DisconnectCurrentIndexChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDataWidgetMapper*>(ptr), static_cast<void (QDataWidgetMapper::*)(int)>(&QDataWidgetMapper::currentIndexChanged), static_cast<MyQDataWidgetMapper*>(ptr), static_cast<void (MyQDataWidgetMapper::*)(int)>(&MyQDataWidgetMapper::Signal_CurrentIndexChanged));
}

void QDataWidgetMapper_CurrentIndexChanged(void* ptr, int index)
{
	static_cast<QDataWidgetMapper*>(ptr)->currentIndexChanged(index);
}

void* QDataWidgetMapper_ItemDelegate(void* ptr)
{
	return static_cast<QDataWidgetMapper*>(ptr)->itemDelegate();
}

void* QDataWidgetMapper_MappedPropertyName(void* ptr, void* widget)
{
		return new QByteArray(static_cast<QDataWidgetMapper*>(ptr)->mappedPropertyName(static_cast<QWidget*>(widget)));
}

int QDataWidgetMapper_MappedSection(void* ptr, void* widget)
{
		return static_cast<QDataWidgetMapper*>(ptr)->mappedSection(static_cast<QWidget*>(widget));
}

void* QDataWidgetMapper_MappedWidgetAt(void* ptr, int section)
{
	return static_cast<QDataWidgetMapper*>(ptr)->mappedWidgetAt(section);
}

void* QDataWidgetMapper_Model(void* ptr)
{
	return static_cast<QDataWidgetMapper*>(ptr)->model();
}

long long QDataWidgetMapper_Orientation(void* ptr)
{
	return static_cast<QDataWidgetMapper*>(ptr)->orientation();
}

void QDataWidgetMapper_RemoveMapping(void* ptr, void* widget)
{
		static_cast<QDataWidgetMapper*>(ptr)->removeMapping(static_cast<QWidget*>(widget));
}

void QDataWidgetMapper_Revert(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "revert");
}

void QDataWidgetMapper_RevertDefault(void* ptr)
{
		static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::revert();
}

void* QDataWidgetMapper_RootIndex(void* ptr)
{
	return new QModelIndex(static_cast<QDataWidgetMapper*>(ptr)->rootIndex());
}

void QDataWidgetMapper_SetCurrentIndex(void* ptr, int index)
{
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "setCurrentIndex", Q_ARG(int, index));
}

void QDataWidgetMapper_SetCurrentIndexDefault(void* ptr, int index)
{
		static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::setCurrentIndex(index);
}

void QDataWidgetMapper_SetCurrentModelIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "setCurrentModelIndex", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QDataWidgetMapper_SetCurrentModelIndexDefault(void* ptr, void* index)
{
		static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::setCurrentModelIndex(*static_cast<QModelIndex*>(index));
}

void QDataWidgetMapper_SetItemDelegate(void* ptr, void* delegate)
{
	static_cast<QDataWidgetMapper*>(ptr)->setItemDelegate(static_cast<QAbstractItemDelegate*>(delegate));
}

void QDataWidgetMapper_SetModel(void* ptr, void* model)
{
	static_cast<QDataWidgetMapper*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}

void QDataWidgetMapper_SetOrientation(void* ptr, long long aOrientation)
{
	static_cast<QDataWidgetMapper*>(ptr)->setOrientation(static_cast<Qt::Orientation>(aOrientation));
}

void QDataWidgetMapper_SetRootIndex(void* ptr, void* index)
{
	static_cast<QDataWidgetMapper*>(ptr)->setRootIndex(*static_cast<QModelIndex*>(index));
}

void QDataWidgetMapper_SetSubmitPolicy(void* ptr, long long policy)
{
	static_cast<QDataWidgetMapper*>(ptr)->setSubmitPolicy(static_cast<QDataWidgetMapper::SubmitPolicy>(policy));
}

char QDataWidgetMapper_Submit(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "submit", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QDataWidgetMapper_SubmitDefault(void* ptr)
{
		return static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::submit();
}

long long QDataWidgetMapper_SubmitPolicy(void* ptr)
{
	return static_cast<QDataWidgetMapper*>(ptr)->submitPolicy();
}

void QDataWidgetMapper_ToFirst(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "toFirst");
}

void QDataWidgetMapper_ToFirstDefault(void* ptr)
{
		static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::toFirst();
}

void QDataWidgetMapper_ToLast(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "toLast");
}

void QDataWidgetMapper_ToLastDefault(void* ptr)
{
		static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::toLast();
}

void QDataWidgetMapper_ToNext(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "toNext");
}

void QDataWidgetMapper_ToNextDefault(void* ptr)
{
		static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::toNext();
}

void QDataWidgetMapper_ToPrevious(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "toPrevious");
}

void QDataWidgetMapper_ToPreviousDefault(void* ptr)
{
		static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::toPrevious();
}

void QDataWidgetMapper_DestroyQDataWidgetMapper(void* ptr)
{
	static_cast<QDataWidgetMapper*>(ptr)->~QDataWidgetMapper();
}

void QDataWidgetMapper_DestroyQDataWidgetMapperDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QDataWidgetMapper___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QDataWidgetMapper___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QDataWidgetMapper___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QDataWidgetMapper___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QDataWidgetMapper___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QDataWidgetMapper___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QDataWidgetMapper___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

void QDataWidgetMapper_DeleteLaterDefault(void* ptr)
{
		static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::deleteLater();
}

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

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

char QDataWidgetMapper_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQDateEdit: public QDateEdit
{
public:
	MyQDateEdit(QWidget *parent = Q_NULLPTR) : QDateEdit(parent) {QDateEdit_QDateEdit_QRegisterMetaType();};
	MyQDateEdit(const QDate &date, QWidget *parent = Q_NULLPTR) : QDateEdit(date, parent) {QDateEdit_QDateEdit_QRegisterMetaType();};
	 ~MyQDateEdit() { callbackQDateEdit_DestroyQDateEdit(this); };
	void clear() { callbackQDateTimeEdit_Clear(this); };
	void Signal_DateChanged(const QDate & date) { callbackQDateTimeEdit_DateChanged(this, const_cast<QDate*>(&date)); };
	void Signal_DateTimeChanged(const QDateTime & datetime) { callbackQDateTimeEdit_DateTimeChanged(this, const_cast<QDateTime*>(&datetime)); };
	QDateTime dateTimeFromText(const QString & text) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };return *static_cast<QDateTime*>(callbackQDateTimeEdit_DateTimeFromText(const_cast<void*>(static_cast<const void*>(this)), textPacked)); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void fixup(QString & input) const { QByteArray* t140f86 = new QByteArray(input.toUtf8()); QtWidgets_PackedString inputPacked = { const_cast<char*>(t140f86->prepend("WHITESPACE").constData()+10), t140f86->size()-10, t140f86 };callbackQAbstractSpinBox_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void setDate(const QDate & date) { callbackQDateTimeEdit_SetDate(this, const_cast<QDate*>(&date)); };
	void setDateTime(const QDateTime & dateTime) { callbackQDateTimeEdit_SetDateTime(this, const_cast<QDateTime*>(&dateTime)); };
	void setTime(const QTime & ti) { callbackQDateTimeEdit_SetTime(this, const_cast<QTime*>(&ti)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void stepBy(int steps) { callbackQAbstractSpinBox_StepBy(this, steps); };
	QAbstractSpinBox::StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQAbstractSpinBox_StepEnabled(const_cast<void*>(static_cast<const void*>(this)))); };
	QString textFromDateTime(const QDateTime & dateTime) const { return ({ QtWidgets_PackedString tempVal = callbackQDateTimeEdit_TextFromDateTime(const_cast<void*>(static_cast<const void*>(this)), const_cast<QDateTime*>(&dateTime)); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void Signal_TimeChanged(const QTime & ti) { callbackQDateTimeEdit_TimeChanged(this, const_cast<QTime*>(&ti)); };
	QValidator::State validate(QString & text, int & pos) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };return static_cast<QValidator::State>(callbackQAbstractSpinBox_Validate(const_cast<void*>(static_cast<const void*>(this)), textPacked, pos)); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_EditingFinished() { callbackQAbstractSpinBox_EditingFinished(this); };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void selectAll() { callbackQAbstractSpinBox_SelectAll(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void stepDown() { callbackQAbstractSpinBox_StepDown(this); };
	void stepUp() { callbackQAbstractSpinBox_StepUp(this); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QDateEdit*)
Q_DECLARE_METATYPE(MyQDateEdit*)

int QDateEdit_QDateEdit_QRegisterMetaType(){qRegisterMetaType<QDateEdit*>(); return qRegisterMetaType<MyQDateEdit*>();}

void* QDateEdit_NewQDateEdit(void* parent)
{
		return new MyQDateEdit(static_cast<QWidget*>(parent));
}

void* QDateEdit_NewQDateEdit2(void* date, void* parent)
{
		return new MyQDateEdit(*static_cast<QDate*>(date), static_cast<QWidget*>(parent));
}

void QDateEdit_DestroyQDateEdit(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->~QDateEdit();
}

void QDateEdit_DestroyQDateEditDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQDateTimeEdit: public QDateTimeEdit
{
public:
	MyQDateTimeEdit(QWidget *parent = Q_NULLPTR) : QDateTimeEdit(parent) {QDateTimeEdit_QDateTimeEdit_QRegisterMetaType();};
	MyQDateTimeEdit(const QDateTime &datetime, QWidget *parent = Q_NULLPTR) : QDateTimeEdit(datetime, parent) {QDateTimeEdit_QDateTimeEdit_QRegisterMetaType();};
	MyQDateTimeEdit(const QDate &date, QWidget *parent = Q_NULLPTR) : QDateTimeEdit(date, parent) {QDateTimeEdit_QDateTimeEdit_QRegisterMetaType();};
	MyQDateTimeEdit(const QTime &ti, QWidget *parent = Q_NULLPTR) : QDateTimeEdit(ti, parent) {QDateTimeEdit_QDateTimeEdit_QRegisterMetaType();};
	void clear() { callbackQDateTimeEdit_Clear(this); };
	void Signal_DateChanged(const QDate & date) { callbackQDateTimeEdit_DateChanged(this, const_cast<QDate*>(&date)); };
	void Signal_DateTimeChanged(const QDateTime & datetime) { callbackQDateTimeEdit_DateTimeChanged(this, const_cast<QDateTime*>(&datetime)); };
	QDateTime dateTimeFromText(const QString & text) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };return *static_cast<QDateTime*>(callbackQDateTimeEdit_DateTimeFromText(const_cast<void*>(static_cast<const void*>(this)), textPacked)); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void fixup(QString & input) const { QByteArray* t140f86 = new QByteArray(input.toUtf8()); QtWidgets_PackedString inputPacked = { const_cast<char*>(t140f86->prepend("WHITESPACE").constData()+10), t140f86->size()-10, t140f86 };callbackQAbstractSpinBox_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void setDate(const QDate & date) { callbackQDateTimeEdit_SetDate(this, const_cast<QDate*>(&date)); };
	void setDateTime(const QDateTime & dateTime) { callbackQDateTimeEdit_SetDateTime(this, const_cast<QDateTime*>(&dateTime)); };
	void setTime(const QTime & ti) { callbackQDateTimeEdit_SetTime(this, const_cast<QTime*>(&ti)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void stepBy(int steps) { callbackQAbstractSpinBox_StepBy(this, steps); };
	QAbstractSpinBox::StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQAbstractSpinBox_StepEnabled(const_cast<void*>(static_cast<const void*>(this)))); };
	QString textFromDateTime(const QDateTime & dateTime) const { return ({ QtWidgets_PackedString tempVal = callbackQDateTimeEdit_TextFromDateTime(const_cast<void*>(static_cast<const void*>(this)), const_cast<QDateTime*>(&dateTime)); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void Signal_TimeChanged(const QTime & ti) { callbackQDateTimeEdit_TimeChanged(this, const_cast<QTime*>(&ti)); };
	QValidator::State validate(QString & text, int & pos) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };return static_cast<QValidator::State>(callbackQAbstractSpinBox_Validate(const_cast<void*>(static_cast<const void*>(this)), textPacked, pos)); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	 ~MyQDateTimeEdit() { callbackQDateTimeEdit_DestroyQDateTimeEdit(this); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_EditingFinished() { callbackQAbstractSpinBox_EditingFinished(this); };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void selectAll() { callbackQAbstractSpinBox_SelectAll(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void stepDown() { callbackQAbstractSpinBox_StepDown(this); };
	void stepUp() { callbackQAbstractSpinBox_StepUp(this); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QDateTimeEdit*)
Q_DECLARE_METATYPE(MyQDateTimeEdit*)

int QDateTimeEdit_QDateTimeEdit_QRegisterMetaType(){qRegisterMetaType<QDateTimeEdit*>(); return qRegisterMetaType<MyQDateTimeEdit*>();}

void* QDateTimeEdit_NewQDateTimeEdit(void* parent)
{
		return new MyQDateTimeEdit(static_cast<QWidget*>(parent));
}

void* QDateTimeEdit_NewQDateTimeEdit2(void* datetime, void* parent)
{
		return new MyQDateTimeEdit(*static_cast<QDateTime*>(datetime), static_cast<QWidget*>(parent));
}

void* QDateTimeEdit_NewQDateTimeEdit3(void* date, void* parent)
{
		return new MyQDateTimeEdit(*static_cast<QDate*>(date), static_cast<QWidget*>(parent));
}

void* QDateTimeEdit_NewQDateTimeEdit4(void* ti, void* parent)
{
		return new MyQDateTimeEdit(*static_cast<QTime*>(ti), static_cast<QWidget*>(parent));
}

char QDateTimeEdit_CalendarPopup(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->calendarPopup();
}

void* QDateTimeEdit_CalendarWidget(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->calendarWidget();
}

void QDateTimeEdit_Clear(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->clear();
}

void QDateTimeEdit_ClearDefault(void* ptr)
{
	if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::clear();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::clear();
	} else {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::clear();
	}
}

void QDateTimeEdit_ClearMaximumDate(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->clearMaximumDate();
}

void QDateTimeEdit_ClearMaximumDateTime(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->clearMaximumDateTime();
}

void QDateTimeEdit_ClearMaximumTime(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->clearMaximumTime();
}

void QDateTimeEdit_ClearMinimumDate(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->clearMinimumDate();
}

void QDateTimeEdit_ClearMinimumDateTime(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->clearMinimumDateTime();
}

void QDateTimeEdit_ClearMinimumTime(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->clearMinimumTime();
}

long long QDateTimeEdit_CurrentSection(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->currentSection();
}

int QDateTimeEdit_CurrentSectionIndex(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->currentSectionIndex();
}

void* QDateTimeEdit_Date(void* ptr)
{
	return new QDate(static_cast<QDateTimeEdit*>(ptr)->date());
}

void QDateTimeEdit_ConnectDateChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QDateTimeEdit*>(ptr), static_cast<void (QDateTimeEdit::*)(const QDate &)>(&QDateTimeEdit::dateChanged), static_cast<MyQDateTimeEdit*>(ptr), static_cast<void (MyQDateTimeEdit::*)(const QDate &)>(&MyQDateTimeEdit::Signal_DateChanged), static_cast<Qt::ConnectionType>(t));
}

void QDateTimeEdit_DisconnectDateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDateTimeEdit*>(ptr), static_cast<void (QDateTimeEdit::*)(const QDate &)>(&QDateTimeEdit::dateChanged), static_cast<MyQDateTimeEdit*>(ptr), static_cast<void (MyQDateTimeEdit::*)(const QDate &)>(&MyQDateTimeEdit::Signal_DateChanged));
}

void QDateTimeEdit_DateChanged(void* ptr, void* date)
{
	static_cast<QDateTimeEdit*>(ptr)->dateChanged(*static_cast<QDate*>(date));
}

void* QDateTimeEdit_DateTime(void* ptr)
{
	return new QDateTime(static_cast<QDateTimeEdit*>(ptr)->dateTime());
}

void QDateTimeEdit_ConnectDateTimeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QDateTimeEdit*>(ptr), static_cast<void (QDateTimeEdit::*)(const QDateTime &)>(&QDateTimeEdit::dateTimeChanged), static_cast<MyQDateTimeEdit*>(ptr), static_cast<void (MyQDateTimeEdit::*)(const QDateTime &)>(&MyQDateTimeEdit::Signal_DateTimeChanged), static_cast<Qt::ConnectionType>(t));
}

void QDateTimeEdit_DisconnectDateTimeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDateTimeEdit*>(ptr), static_cast<void (QDateTimeEdit::*)(const QDateTime &)>(&QDateTimeEdit::dateTimeChanged), static_cast<MyQDateTimeEdit*>(ptr), static_cast<void (MyQDateTimeEdit::*)(const QDateTime &)>(&MyQDateTimeEdit::Signal_DateTimeChanged));
}

void QDateTimeEdit_DateTimeChanged(void* ptr, void* datetime)
{
	static_cast<QDateTimeEdit*>(ptr)->dateTimeChanged(*static_cast<QDateTime*>(datetime));
}

void* QDateTimeEdit_DateTimeFromText(void* ptr, struct QtWidgets_PackedString text)
{
	return new QDateTime(static_cast<QDateTimeEdit*>(ptr)->dateTimeFromText(QString::fromUtf8(text.data, text.len)));
}

void* QDateTimeEdit_DateTimeFromTextDefault(void* ptr, struct QtWidgets_PackedString text)
{
	if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return new QDateTime(static_cast<QDateEdit*>(ptr)->QDateEdit::dateTimeFromText(QString::fromUtf8(text.data, text.len)));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return new QDateTime(static_cast<QTimeEdit*>(ptr)->QTimeEdit::dateTimeFromText(QString::fromUtf8(text.data, text.len)));
	} else {
		return new QDateTime(static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::dateTimeFromText(QString::fromUtf8(text.data, text.len)));
	}
}

struct QtWidgets_PackedString QDateTimeEdit_DisplayFormat(void* ptr)
{
	return ({ QByteArray* t18a499 = new QByteArray(static_cast<QDateTimeEdit*>(ptr)->displayFormat().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t18a499->prepend("WHITESPACE").constData()+10), t18a499->size()-10, t18a499 }; });
}

long long QDateTimeEdit_DisplayedSections(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->displayedSections();
}

void* QDateTimeEdit_MaximumDate(void* ptr)
{
	return new QDate(static_cast<QDateTimeEdit*>(ptr)->maximumDate());
}

void* QDateTimeEdit_MaximumDateTime(void* ptr)
{
	return new QDateTime(static_cast<QDateTimeEdit*>(ptr)->maximumDateTime());
}

void* QDateTimeEdit_MaximumTime(void* ptr)
{
	return new QTime(static_cast<QDateTimeEdit*>(ptr)->maximumTime());
}

void* QDateTimeEdit_MinimumDate(void* ptr)
{
	return new QDate(static_cast<QDateTimeEdit*>(ptr)->minimumDate());
}

void* QDateTimeEdit_MinimumDateTime(void* ptr)
{
	return new QDateTime(static_cast<QDateTimeEdit*>(ptr)->minimumDateTime());
}

void* QDateTimeEdit_MinimumTime(void* ptr)
{
	return new QTime(static_cast<QDateTimeEdit*>(ptr)->minimumTime());
}

long long QDateTimeEdit_SectionAt(void* ptr, int index)
{
	return static_cast<QDateTimeEdit*>(ptr)->sectionAt(index);
}

int QDateTimeEdit_SectionCount(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->sectionCount();
}

struct QtWidgets_PackedString QDateTimeEdit_SectionText(void* ptr, long long section)
{
	return ({ QByteArray* tdf4510 = new QByteArray(static_cast<QDateTimeEdit*>(ptr)->sectionText(static_cast<QDateTimeEdit::Section>(section)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tdf4510->prepend("WHITESPACE").constData()+10), tdf4510->size()-10, tdf4510 }; });
}

void QDateTimeEdit_SetCalendarPopup(void* ptr, char enable)
{
	static_cast<QDateTimeEdit*>(ptr)->setCalendarPopup(enable != 0);
}

void QDateTimeEdit_SetCalendarWidget(void* ptr, void* calendarWidget)
{
	static_cast<QDateTimeEdit*>(ptr)->setCalendarWidget(static_cast<QCalendarWidget*>(calendarWidget));
}

void QDateTimeEdit_SetCurrentSection(void* ptr, long long section)
{
	static_cast<QDateTimeEdit*>(ptr)->setCurrentSection(static_cast<QDateTimeEdit::Section>(section));
}

void QDateTimeEdit_SetCurrentSectionIndex(void* ptr, int index)
{
	static_cast<QDateTimeEdit*>(ptr)->setCurrentSectionIndex(index);
}

void QDateTimeEdit_SetDate(void* ptr, void* date)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setDate", Q_ARG(const QDate, *static_cast<QDate*>(date)));
}

void QDateTimeEdit_SetDateDefault(void* ptr, void* date)
{
	if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::setDate(*static_cast<QDate*>(date));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::setDate(*static_cast<QDate*>(date));
	} else {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setDate(*static_cast<QDate*>(date));
	}
}

void QDateTimeEdit_SetDateRange(void* ptr, void* min, void* max)
{
	static_cast<QDateTimeEdit*>(ptr)->setDateRange(*static_cast<QDate*>(min), *static_cast<QDate*>(max));
}

void QDateTimeEdit_SetDateTime(void* ptr, void* dateTime)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setDateTime", Q_ARG(const QDateTime, *static_cast<QDateTime*>(dateTime)));
}

void QDateTimeEdit_SetDateTimeDefault(void* ptr, void* dateTime)
{
	if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::setDateTime(*static_cast<QDateTime*>(dateTime));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::setDateTime(*static_cast<QDateTime*>(dateTime));
	} else {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setDateTime(*static_cast<QDateTime*>(dateTime));
	}
}

void QDateTimeEdit_SetDateTimeRange(void* ptr, void* min, void* max)
{
	static_cast<QDateTimeEdit*>(ptr)->setDateTimeRange(*static_cast<QDateTime*>(min), *static_cast<QDateTime*>(max));
}

void QDateTimeEdit_SetDisplayFormat(void* ptr, struct QtWidgets_PackedString format)
{
	static_cast<QDateTimeEdit*>(ptr)->setDisplayFormat(QString::fromUtf8(format.data, format.len));
}

void QDateTimeEdit_SetMaximumDate(void* ptr, void* max)
{
	static_cast<QDateTimeEdit*>(ptr)->setMaximumDate(*static_cast<QDate*>(max));
}

void QDateTimeEdit_SetMaximumDateTime(void* ptr, void* dt)
{
	static_cast<QDateTimeEdit*>(ptr)->setMaximumDateTime(*static_cast<QDateTime*>(dt));
}

void QDateTimeEdit_SetMaximumTime(void* ptr, void* max)
{
	static_cast<QDateTimeEdit*>(ptr)->setMaximumTime(*static_cast<QTime*>(max));
}

void QDateTimeEdit_SetMinimumDate(void* ptr, void* min)
{
	static_cast<QDateTimeEdit*>(ptr)->setMinimumDate(*static_cast<QDate*>(min));
}

void QDateTimeEdit_SetMinimumDateTime(void* ptr, void* dt)
{
	static_cast<QDateTimeEdit*>(ptr)->setMinimumDateTime(*static_cast<QDateTime*>(dt));
}

void QDateTimeEdit_SetMinimumTime(void* ptr, void* min)
{
	static_cast<QDateTimeEdit*>(ptr)->setMinimumTime(*static_cast<QTime*>(min));
}

void QDateTimeEdit_SetSelectedSection(void* ptr, long long section)
{
	static_cast<QDateTimeEdit*>(ptr)->setSelectedSection(static_cast<QDateTimeEdit::Section>(section));
}

void QDateTimeEdit_SetTime(void* ptr, void* ti)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setTime", Q_ARG(const QTime, *static_cast<QTime*>(ti)));
}

void QDateTimeEdit_SetTimeDefault(void* ptr, void* ti)
{
	if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::setTime(*static_cast<QTime*>(ti));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::setTime(*static_cast<QTime*>(ti));
	} else {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setTime(*static_cast<QTime*>(ti));
	}
}

void QDateTimeEdit_SetTimeRange(void* ptr, void* min, void* max)
{
	static_cast<QDateTimeEdit*>(ptr)->setTimeRange(*static_cast<QTime*>(min), *static_cast<QTime*>(max));
}

void QDateTimeEdit_SetTimeSpec(void* ptr, long long spec)
{
	static_cast<QDateTimeEdit*>(ptr)->setTimeSpec(static_cast<Qt::TimeSpec>(spec));
}

struct QtWidgets_PackedString QDateTimeEdit_TextFromDateTime(void* ptr, void* dateTime)
{
	return ({ QByteArray* t00949f = new QByteArray(static_cast<QDateTimeEdit*>(ptr)->textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t00949f->prepend("WHITESPACE").constData()+10), t00949f->size()-10, t00949f }; });
}

struct QtWidgets_PackedString QDateTimeEdit_TextFromDateTimeDefault(void* ptr, void* dateTime)
{
	if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QByteArray* t15f412 = new QByteArray(static_cast<QDateEdit*>(ptr)->QDateEdit::textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t15f412->prepend("WHITESPACE").constData()+10), t15f412->size()-10, t15f412 }; });
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QByteArray* t15f412 = new QByteArray(static_cast<QTimeEdit*>(ptr)->QTimeEdit::textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t15f412->prepend("WHITESPACE").constData()+10), t15f412->size()-10, t15f412 }; });
	} else {
		return ({ QByteArray* t15f412 = new QByteArray(static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t15f412->prepend("WHITESPACE").constData()+10), t15f412->size()-10, t15f412 }; });
	}
}

void* QDateTimeEdit_Time(void* ptr)
{
	return new QTime(static_cast<QDateTimeEdit*>(ptr)->time());
}

void QDateTimeEdit_ConnectTimeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QDateTimeEdit*>(ptr), static_cast<void (QDateTimeEdit::*)(const QTime &)>(&QDateTimeEdit::timeChanged), static_cast<MyQDateTimeEdit*>(ptr), static_cast<void (MyQDateTimeEdit::*)(const QTime &)>(&MyQDateTimeEdit::Signal_TimeChanged), static_cast<Qt::ConnectionType>(t));
}

void QDateTimeEdit_DisconnectTimeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDateTimeEdit*>(ptr), static_cast<void (QDateTimeEdit::*)(const QTime &)>(&QDateTimeEdit::timeChanged), static_cast<MyQDateTimeEdit*>(ptr), static_cast<void (MyQDateTimeEdit::*)(const QTime &)>(&MyQDateTimeEdit::Signal_TimeChanged));
}

void QDateTimeEdit_TimeChanged(void* ptr, void* ti)
{
	static_cast<QDateTimeEdit*>(ptr)->timeChanged(*static_cast<QTime*>(ti));
}

long long QDateTimeEdit_TimeSpec(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->timeSpec();
}

void QDateTimeEdit_DestroyQDateTimeEdit(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->~QDateTimeEdit();
}

void QDateTimeEdit_DestroyQDateTimeEditDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQDesktopWidget: public QDesktopWidget
{
public:
	MyQDesktopWidget() : QDesktopWidget() {QDesktopWidget_QDesktopWidget_QRegisterMetaType();};
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_PrimaryScreenChanged() { callbackQDesktopWidget_PrimaryScreenChanged(this); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void Signal_Resized(int screen) { callbackQDesktopWidget_Resized(this, screen); };
	void Signal_ScreenCountChanged(int newCount) { callbackQDesktopWidget_ScreenCountChanged(this, newCount); };
	void Signal_WorkAreaResized(int screen) { callbackQDesktopWidget_WorkAreaResized(this, screen); };
	 ~MyQDesktopWidget() { callbackQDesktopWidget_DestroyQDesktopWidget(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QDesktopWidget*)
Q_DECLARE_METATYPE(MyQDesktopWidget*)

int QDesktopWidget_QDesktopWidget_QRegisterMetaType(){qRegisterMetaType<QDesktopWidget*>(); return qRegisterMetaType<MyQDesktopWidget*>();}

void* QDesktopWidget_NewQDesktopWidget()
{
	return new MyQDesktopWidget();
}

void* QDesktopWidget_AvailableGeometry(void* ptr, int screen)
{
	return ({ QRect tmpValue = static_cast<QDesktopWidget*>(ptr)->availableGeometry(screen); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QDesktopWidget_AvailableGeometry2(void* ptr, void* widget)
{
		return ({ QRect tmpValue = static_cast<QDesktopWidget*>(ptr)->availableGeometry(static_cast<QWidget*>(widget)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

char QDesktopWidget_IsVirtualDesktop(void* ptr)
{
	return static_cast<QDesktopWidget*>(ptr)->isVirtualDesktop();
}

int QDesktopWidget_NumScreens(void* ptr)
{
	return static_cast<QDesktopWidget*>(ptr)->numScreens();
}

int QDesktopWidget_PrimaryScreen(void* ptr)
{
	return static_cast<QDesktopWidget*>(ptr)->primaryScreen();
}

void QDesktopWidget_ConnectPrimaryScreenChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QDesktopWidget*>(ptr), static_cast<void (QDesktopWidget::*)()>(&QDesktopWidget::primaryScreenChanged), static_cast<MyQDesktopWidget*>(ptr), static_cast<void (MyQDesktopWidget::*)()>(&MyQDesktopWidget::Signal_PrimaryScreenChanged), static_cast<Qt::ConnectionType>(t));
}

void QDesktopWidget_DisconnectPrimaryScreenChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDesktopWidget*>(ptr), static_cast<void (QDesktopWidget::*)()>(&QDesktopWidget::primaryScreenChanged), static_cast<MyQDesktopWidget*>(ptr), static_cast<void (MyQDesktopWidget::*)()>(&MyQDesktopWidget::Signal_PrimaryScreenChanged));
}

void QDesktopWidget_PrimaryScreenChanged(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->primaryScreenChanged();
}

void QDesktopWidget_ConnectResized(void* ptr, long long t)
{
	QObject::connect(static_cast<QDesktopWidget*>(ptr), static_cast<void (QDesktopWidget::*)(int)>(&QDesktopWidget::resized), static_cast<MyQDesktopWidget*>(ptr), static_cast<void (MyQDesktopWidget::*)(int)>(&MyQDesktopWidget::Signal_Resized), static_cast<Qt::ConnectionType>(t));
}

void QDesktopWidget_DisconnectResized(void* ptr)
{
	QObject::disconnect(static_cast<QDesktopWidget*>(ptr), static_cast<void (QDesktopWidget::*)(int)>(&QDesktopWidget::resized), static_cast<MyQDesktopWidget*>(ptr), static_cast<void (MyQDesktopWidget::*)(int)>(&MyQDesktopWidget::Signal_Resized));
}

void QDesktopWidget_Resized(void* ptr, int screen)
{
	static_cast<QDesktopWidget*>(ptr)->resized(screen);
}

void* QDesktopWidget_Screen(void* ptr, int screen)
{
	return static_cast<QDesktopWidget*>(ptr)->screen(screen);
}

int QDesktopWidget_ScreenCount(void* ptr)
{
	return static_cast<QDesktopWidget*>(ptr)->screenCount();
}

void QDesktopWidget_ConnectScreenCountChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QDesktopWidget*>(ptr), static_cast<void (QDesktopWidget::*)(int)>(&QDesktopWidget::screenCountChanged), static_cast<MyQDesktopWidget*>(ptr), static_cast<void (MyQDesktopWidget::*)(int)>(&MyQDesktopWidget::Signal_ScreenCountChanged), static_cast<Qt::ConnectionType>(t));
}

void QDesktopWidget_DisconnectScreenCountChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDesktopWidget*>(ptr), static_cast<void (QDesktopWidget::*)(int)>(&QDesktopWidget::screenCountChanged), static_cast<MyQDesktopWidget*>(ptr), static_cast<void (MyQDesktopWidget::*)(int)>(&MyQDesktopWidget::Signal_ScreenCountChanged));
}

void QDesktopWidget_ScreenCountChanged(void* ptr, int newCount)
{
	static_cast<QDesktopWidget*>(ptr)->screenCountChanged(newCount);
}

void* QDesktopWidget_ScreenGeometry(void* ptr, int screen)
{
	return ({ QRect tmpValue = static_cast<QDesktopWidget*>(ptr)->screenGeometry(screen); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QDesktopWidget_ScreenGeometry2(void* ptr, void* widget)
{
		return ({ QRect tmpValue = static_cast<QDesktopWidget*>(ptr)->screenGeometry(static_cast<QWidget*>(widget)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

int QDesktopWidget_ScreenNumber(void* ptr, void* widget)
{
		return static_cast<QDesktopWidget*>(ptr)->screenNumber(static_cast<QWidget*>(widget));
}

int QDesktopWidget_ScreenNumber2(void* ptr, void* point)
{
	return static_cast<QDesktopWidget*>(ptr)->screenNumber(*static_cast<QPoint*>(point));
}

void QDesktopWidget_ConnectWorkAreaResized(void* ptr, long long t)
{
	QObject::connect(static_cast<QDesktopWidget*>(ptr), static_cast<void (QDesktopWidget::*)(int)>(&QDesktopWidget::workAreaResized), static_cast<MyQDesktopWidget*>(ptr), static_cast<void (MyQDesktopWidget::*)(int)>(&MyQDesktopWidget::Signal_WorkAreaResized), static_cast<Qt::ConnectionType>(t));
}

void QDesktopWidget_DisconnectWorkAreaResized(void* ptr)
{
	QObject::disconnect(static_cast<QDesktopWidget*>(ptr), static_cast<void (QDesktopWidget::*)(int)>(&QDesktopWidget::workAreaResized), static_cast<MyQDesktopWidget*>(ptr), static_cast<void (MyQDesktopWidget::*)(int)>(&MyQDesktopWidget::Signal_WorkAreaResized));
}

void QDesktopWidget_WorkAreaResized(void* ptr, int screen)
{
	static_cast<QDesktopWidget*>(ptr)->workAreaResized(screen);
}

void QDesktopWidget_DestroyQDesktopWidget(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->~QDesktopWidget();
}

void QDesktopWidget_DestroyQDesktopWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQDial: public QDial
{
public:
	MyQDial(QWidget *parent = Q_NULLPTR) : QDial(parent) {QDial_QDial_QRegisterMetaType();};
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * pe) { callbackQWidget_PaintEvent(this, pe); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void setNotchesVisible(bool visible) { callbackQDial_SetNotchesVisible(this, visible); };
	void setWrapping(bool on) { callbackQDial_SetWrapping(this, on); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void sliderChange(QAbstractSlider::SliderChange change) { callbackQAbstractSlider_SliderChange(this, change); };
	 ~MyQDial() { callbackQDial_DestroyQDial(this); };
	void Signal_ActionTriggered(int action) { callbackQAbstractSlider_ActionTriggered(this, action); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void keyPressEvent(QKeyEvent * ev) { callbackQWidget_KeyPressEvent(this, ev); };
	void Signal_RangeChanged(int min, int max) { callbackQAbstractSlider_RangeChanged(this, min, max); };
	void setOrientation(Qt::Orientation vqt) { callbackQAbstractSlider_SetOrientation(this, vqt); };
	void setRange(int min, int max) { callbackQAbstractSlider_SetRange(this, min, max); };
	void setValue(int vin) { callbackQAbstractSlider_SetValue(this, vin); };
	void Signal_SliderMoved(int value) { callbackQAbstractSlider_SliderMoved(this, value); };
	void Signal_SliderPressed() { callbackQAbstractSlider_SliderPressed(this); };
	void Signal_SliderReleased() { callbackQAbstractSlider_SliderReleased(this); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void Signal_ValueChanged(int value) { callbackQAbstractSlider_ValueChanged(this, value); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QDial*)
Q_DECLARE_METATYPE(MyQDial*)

int QDial_QDial_QRegisterMetaType(){qRegisterMetaType<QDial*>(); return qRegisterMetaType<MyQDial*>();}

void* QDial_NewQDial(void* parent)
{
		return new MyQDial(static_cast<QWidget*>(parent));
}

void QDial_InitStyleOption(void* ptr, void* option)
{
	static_cast<QDial*>(ptr)->initStyleOption(static_cast<QStyleOptionSlider*>(option));
}

int QDial_NotchSize(void* ptr)
{
	return static_cast<QDial*>(ptr)->notchSize();
}

double QDial_NotchTarget(void* ptr)
{
	return static_cast<QDial*>(ptr)->notchTarget();
}

char QDial_NotchesVisible(void* ptr)
{
	return static_cast<QDial*>(ptr)->notchesVisible();
}

void QDial_SetNotchTarget(void* ptr, double target)
{
	static_cast<QDial*>(ptr)->setNotchTarget(target);
}

void QDial_SetNotchesVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setNotchesVisible", Q_ARG(bool, visible != 0));
}

void QDial_SetNotchesVisibleDefault(void* ptr, char visible)
{
		static_cast<QDial*>(ptr)->QDial::setNotchesVisible(visible != 0);
}

void QDial_SetWrapping(void* ptr, char on)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setWrapping", Q_ARG(bool, on != 0));
}

void QDial_SetWrappingDefault(void* ptr, char on)
{
		static_cast<QDial*>(ptr)->QDial::setWrapping(on != 0);
}

char QDial_Wrapping(void* ptr)
{
	return static_cast<QDial*>(ptr)->wrapping();
}

void QDial_DestroyQDial(void* ptr)
{
	static_cast<QDial*>(ptr)->~QDial();
}

void QDial_DestroyQDialDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQDialog: public QDialog
{
public:
	MyQDialog(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QDialog(parent, ff) {QDialog_QDialog_QRegisterMetaType();};
	void accept() { callbackQDialog_Accept(this); };
	void Signal_Accepted() { callbackQDialog_Accepted(this); };
	void closeEvent(QCloseEvent * e) { callbackQWidget_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	void done(int r) { callbackQDialog_Done(this, r); };
	bool eventFilter(QObject * o, QEvent * e) { return callbackQWidget_EventFilter(this, o, e) != 0; };
	int exec() { return callbackQDialog_Exec(this); };
	void Signal_Finished(int result) { callbackQDialog_Finished(this, result); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void open() { callbackQDialog_Open(this); };
	void reject() { callbackQDialog_Reject(this); };
	void Signal_Rejected() { callbackQDialog_Rejected(this); };
	void resizeEvent(QResizeEvent * vqr) { callbackQWidget_ResizeEvent(this, vqr); };
	void setVisible(bool visible) { callbackQDialog_SetVisible(this, visible); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQDialog() { callbackQDialog_DestroyQDialog(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QDialog*)
Q_DECLARE_METATYPE(MyQDialog*)

int QDialog_QDialog_QRegisterMetaType(){qRegisterMetaType<QDialog*>(); return qRegisterMetaType<MyQDialog*>();}

void* QDialog_NewQDialog(void* parent, long long ff)
{
		return new MyQDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}

void QDialog_Accept(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "accept");
}

void QDialog_AcceptDefault(void* ptr)
{
	if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::accept();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::accept();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::accept();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::accept();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::accept();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::accept();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::accept();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::accept();
	} else {
		static_cast<QDialog*>(ptr)->QDialog::accept();
	}
}

void QDialog_ConnectAccepted(void* ptr, long long t)
{
	QObject::connect(static_cast<QDialog*>(ptr), static_cast<void (QDialog::*)()>(&QDialog::accepted), static_cast<MyQDialog*>(ptr), static_cast<void (MyQDialog::*)()>(&MyQDialog::Signal_Accepted), static_cast<Qt::ConnectionType>(t));
}

void QDialog_DisconnectAccepted(void* ptr)
{
	QObject::disconnect(static_cast<QDialog*>(ptr), static_cast<void (QDialog::*)()>(&QDialog::accepted), static_cast<MyQDialog*>(ptr), static_cast<void (MyQDialog::*)()>(&MyQDialog::Signal_Accepted));
}

void QDialog_Accepted(void* ptr)
{
	static_cast<QDialog*>(ptr)->accepted();
}

void QDialog_Done(void* ptr, int r)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "done", Q_ARG(int, r));
}

void QDialog_DoneDefault(void* ptr, int r)
{
	if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::done(r);
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::done(r);
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::done(r);
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::done(r);
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::done(r);
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::done(r);
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::done(r);
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::done(r);
	} else {
		static_cast<QDialog*>(ptr)->QDialog::done(r);
	}
}

int QDialog_Exec(void* ptr)
{
	int returnArg;
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "exec", Q_RETURN_ARG(int, returnArg));
	return returnArg;
}

int QDialog_ExecDefault(void* ptr)
{
	if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizard*>(ptr)->QWizard::exec();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMessageBox*>(ptr)->QMessageBox::exec();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QInputDialog*>(ptr)->QInputDialog::exec();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressDialog*>(ptr)->QProgressDialog::exec();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontDialog*>(ptr)->QFontDialog::exec();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFileDialog*>(ptr)->QFileDialog::exec();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QErrorMessage*>(ptr)->QErrorMessage::exec();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColorDialog*>(ptr)->QColorDialog::exec();
	} else {
		return static_cast<QDialog*>(ptr)->QDialog::exec();
	}
}

void QDialog_ConnectFinished(void* ptr, long long t)
{
	QObject::connect(static_cast<QDialog*>(ptr), static_cast<void (QDialog::*)(int)>(&QDialog::finished), static_cast<MyQDialog*>(ptr), static_cast<void (MyQDialog::*)(int)>(&MyQDialog::Signal_Finished), static_cast<Qt::ConnectionType>(t));
}

void QDialog_DisconnectFinished(void* ptr)
{
	QObject::disconnect(static_cast<QDialog*>(ptr), static_cast<void (QDialog::*)(int)>(&QDialog::finished), static_cast<MyQDialog*>(ptr), static_cast<void (MyQDialog::*)(int)>(&MyQDialog::Signal_Finished));
}

void QDialog_Finished(void* ptr, int result)
{
	static_cast<QDialog*>(ptr)->finished(result);
}

char QDialog_IsSizeGripEnabled(void* ptr)
{
	return static_cast<QDialog*>(ptr)->isSizeGripEnabled();
}

void QDialog_Open(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "open");
}

void QDialog_OpenDefault(void* ptr)
{
	if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::open();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::open();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::open();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::open();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::open();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::open();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::open();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::open();
	} else {
		static_cast<QDialog*>(ptr)->QDialog::open();
	}
}

void QDialog_Reject(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "reject");
}

void QDialog_RejectDefault(void* ptr)
{
	if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::reject();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::reject();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::reject();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::reject();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::reject();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::reject();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::reject();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::reject();
	} else {
		static_cast<QDialog*>(ptr)->QDialog::reject();
	}
}

void QDialog_ConnectRejected(void* ptr, long long t)
{
	QObject::connect(static_cast<QDialog*>(ptr), static_cast<void (QDialog::*)()>(&QDialog::rejected), static_cast<MyQDialog*>(ptr), static_cast<void (MyQDialog::*)()>(&MyQDialog::Signal_Rejected), static_cast<Qt::ConnectionType>(t));
}

void QDialog_DisconnectRejected(void* ptr)
{
	QObject::disconnect(static_cast<QDialog*>(ptr), static_cast<void (QDialog::*)()>(&QDialog::rejected), static_cast<MyQDialog*>(ptr), static_cast<void (MyQDialog::*)()>(&MyQDialog::Signal_Rejected));
}

void QDialog_Rejected(void* ptr)
{
	static_cast<QDialog*>(ptr)->rejected();
}

int QDialog_Result(void* ptr)
{
	return static_cast<QDialog*>(ptr)->result();
}

void QDialog_SetModal(void* ptr, char modal)
{
	static_cast<QDialog*>(ptr)->setModal(modal != 0);
}

void QDialog_SetResult(void* ptr, int i)
{
	static_cast<QDialog*>(ptr)->setResult(i);
}

void QDialog_SetSizeGripEnabled(void* ptr, char vbo)
{
	static_cast<QDialog*>(ptr)->setSizeGripEnabled(vbo != 0);
}

void QDialog_SetVisible(void* ptr, char visible)
{
	static_cast<QDialog*>(ptr)->setVisible(visible != 0);
}

void QDialog_SetVisibleDefault(void* ptr, char visible)
{
	if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::setVisible(visible != 0);
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::setVisible(visible != 0);
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::setVisible(visible != 0);
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setVisible(visible != 0);
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::setVisible(visible != 0);
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::setVisible(visible != 0);
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::setVisible(visible != 0);
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::setVisible(visible != 0);
	} else {
		static_cast<QDialog*>(ptr)->QDialog::setVisible(visible != 0);
	}
}

void QDialog_DestroyQDialog(void* ptr)
{
	static_cast<QDialog*>(ptr)->~QDialog();
}

void QDialog_DestroyQDialogDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQDialogButtonBox: public QDialogButtonBox
{
public:
	MyQDialogButtonBox(QWidget *parent = Q_NULLPTR) : QDialogButtonBox(parent) {QDialogButtonBox_QDialogButtonBox_QRegisterMetaType();};
	MyQDialogButtonBox(Qt::Orientation orientation, QWidget *parent = Q_NULLPTR) : QDialogButtonBox(orientation, parent) {QDialogButtonBox_QDialogButtonBox_QRegisterMetaType();};
	MyQDialogButtonBox(QDialogButtonBox::StandardButtons buttons, QWidget *parent = Q_NULLPTR) : QDialogButtonBox(buttons, parent) {QDialogButtonBox_QDialogButtonBox_QRegisterMetaType();};
	MyQDialogButtonBox(QDialogButtonBox::StandardButtons buttons, Qt::Orientation orientation, QWidget *parent = Q_NULLPTR) : QDialogButtonBox(buttons, orientation, parent) {QDialogButtonBox_QDialogButtonBox_QRegisterMetaType();};
	void Signal_Accepted() { callbackQDialogButtonBox_Accepted(this); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	void Signal_Clicked(QAbstractButton * button) { callbackQDialogButtonBox_Clicked(this, button); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void Signal_HelpRequested() { callbackQDialogButtonBox_HelpRequested(this); };
	void Signal_Rejected() { callbackQDialogButtonBox_Rejected(this); };
	 ~MyQDialogButtonBox() { callbackQDialogButtonBox_DestroyQDialogButtonBox(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QDialogButtonBox*)
Q_DECLARE_METATYPE(MyQDialogButtonBox*)

int QDialogButtonBox_QDialogButtonBox_QRegisterMetaType(){qRegisterMetaType<QDialogButtonBox*>(); return qRegisterMetaType<MyQDialogButtonBox*>();}

int QDialogButtonBox_AndroidLayout_Type()
{
	return QDialogButtonBox::AndroidLayout;
}

void* QDialogButtonBox_NewQDialogButtonBox(void* parent)
{
		return new MyQDialogButtonBox(static_cast<QWidget*>(parent));
}

void* QDialogButtonBox_NewQDialogButtonBox2(long long orientation, void* parent)
{
		return new MyQDialogButtonBox(static_cast<Qt::Orientation>(orientation), static_cast<QWidget*>(parent));
}

void* QDialogButtonBox_NewQDialogButtonBox3(long long buttons, void* parent)
{
		return new MyQDialogButtonBox(static_cast<QDialogButtonBox::StandardButton>(buttons), static_cast<QWidget*>(parent));
}

void* QDialogButtonBox_NewQDialogButtonBox4(long long buttons, long long orientation, void* parent)
{
		return new MyQDialogButtonBox(static_cast<QDialogButtonBox::StandardButton>(buttons), static_cast<Qt::Orientation>(orientation), static_cast<QWidget*>(parent));
}

void QDialogButtonBox_ConnectAccepted(void* ptr, long long t)
{
	QObject::connect(static_cast<QDialogButtonBox*>(ptr), static_cast<void (QDialogButtonBox::*)()>(&QDialogButtonBox::accepted), static_cast<MyQDialogButtonBox*>(ptr), static_cast<void (MyQDialogButtonBox::*)()>(&MyQDialogButtonBox::Signal_Accepted), static_cast<Qt::ConnectionType>(t));
}

void QDialogButtonBox_DisconnectAccepted(void* ptr)
{
	QObject::disconnect(static_cast<QDialogButtonBox*>(ptr), static_cast<void (QDialogButtonBox::*)()>(&QDialogButtonBox::accepted), static_cast<MyQDialogButtonBox*>(ptr), static_cast<void (MyQDialogButtonBox::*)()>(&MyQDialogButtonBox::Signal_Accepted));
}

void QDialogButtonBox_Accepted(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->accepted();
}

void QDialogButtonBox_AddButton(void* ptr, void* button, long long role)
{
	static_cast<QDialogButtonBox*>(ptr)->addButton(static_cast<QAbstractButton*>(button), static_cast<QDialogButtonBox::ButtonRole>(role));
}

void* QDialogButtonBox_AddButton2(void* ptr, struct QtWidgets_PackedString text, long long role)
{
	return static_cast<QDialogButtonBox*>(ptr)->addButton(QString::fromUtf8(text.data, text.len), static_cast<QDialogButtonBox::ButtonRole>(role));
}

void* QDialogButtonBox_AddButton3(void* ptr, long long button)
{
	return static_cast<QDialogButtonBox*>(ptr)->addButton(static_cast<QDialogButtonBox::StandardButton>(button));
}

void* QDialogButtonBox_Button(void* ptr, long long which)
{
	return static_cast<QDialogButtonBox*>(ptr)->button(static_cast<QDialogButtonBox::StandardButton>(which));
}

long long QDialogButtonBox_ButtonRole(void* ptr, void* button)
{
	return static_cast<QDialogButtonBox*>(ptr)->buttonRole(static_cast<QAbstractButton*>(button));
}

struct QtWidgets_PackedList QDialogButtonBox_Buttons(void* ptr)
{
	return ({ QList<QAbstractButton *>* tmpValuea9cc79 = new QList<QAbstractButton *>(static_cast<QDialogButtonBox*>(ptr)->buttons()); QtWidgets_PackedList { tmpValuea9cc79, tmpValuea9cc79->size() }; });
}

char QDialogButtonBox_CenterButtons(void* ptr)
{
	return static_cast<QDialogButtonBox*>(ptr)->centerButtons();
}

void QDialogButtonBox_Clear(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->clear();
}

void QDialogButtonBox_ConnectClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QDialogButtonBox*>(ptr), static_cast<void (QDialogButtonBox::*)(QAbstractButton *)>(&QDialogButtonBox::clicked), static_cast<MyQDialogButtonBox*>(ptr), static_cast<void (MyQDialogButtonBox::*)(QAbstractButton *)>(&MyQDialogButtonBox::Signal_Clicked), static_cast<Qt::ConnectionType>(t));
}

void QDialogButtonBox_DisconnectClicked(void* ptr)
{
	QObject::disconnect(static_cast<QDialogButtonBox*>(ptr), static_cast<void (QDialogButtonBox::*)(QAbstractButton *)>(&QDialogButtonBox::clicked), static_cast<MyQDialogButtonBox*>(ptr), static_cast<void (MyQDialogButtonBox::*)(QAbstractButton *)>(&MyQDialogButtonBox::Signal_Clicked));
}

void QDialogButtonBox_Clicked(void* ptr, void* button)
{
	static_cast<QDialogButtonBox*>(ptr)->clicked(static_cast<QAbstractButton*>(button));
}

void QDialogButtonBox_ConnectHelpRequested(void* ptr, long long t)
{
	QObject::connect(static_cast<QDialogButtonBox*>(ptr), static_cast<void (QDialogButtonBox::*)()>(&QDialogButtonBox::helpRequested), static_cast<MyQDialogButtonBox*>(ptr), static_cast<void (MyQDialogButtonBox::*)()>(&MyQDialogButtonBox::Signal_HelpRequested), static_cast<Qt::ConnectionType>(t));
}

void QDialogButtonBox_DisconnectHelpRequested(void* ptr)
{
	QObject::disconnect(static_cast<QDialogButtonBox*>(ptr), static_cast<void (QDialogButtonBox::*)()>(&QDialogButtonBox::helpRequested), static_cast<MyQDialogButtonBox*>(ptr), static_cast<void (MyQDialogButtonBox::*)()>(&MyQDialogButtonBox::Signal_HelpRequested));
}

void QDialogButtonBox_HelpRequested(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->helpRequested();
}

long long QDialogButtonBox_Orientation(void* ptr)
{
	return static_cast<QDialogButtonBox*>(ptr)->orientation();
}

void QDialogButtonBox_ConnectRejected(void* ptr, long long t)
{
	QObject::connect(static_cast<QDialogButtonBox*>(ptr), static_cast<void (QDialogButtonBox::*)()>(&QDialogButtonBox::rejected), static_cast<MyQDialogButtonBox*>(ptr), static_cast<void (MyQDialogButtonBox::*)()>(&MyQDialogButtonBox::Signal_Rejected), static_cast<Qt::ConnectionType>(t));
}

void QDialogButtonBox_DisconnectRejected(void* ptr)
{
	QObject::disconnect(static_cast<QDialogButtonBox*>(ptr), static_cast<void (QDialogButtonBox::*)()>(&QDialogButtonBox::rejected), static_cast<MyQDialogButtonBox*>(ptr), static_cast<void (MyQDialogButtonBox::*)()>(&MyQDialogButtonBox::Signal_Rejected));
}

void QDialogButtonBox_Rejected(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->rejected();
}

void QDialogButtonBox_RemoveButton(void* ptr, void* button)
{
	static_cast<QDialogButtonBox*>(ptr)->removeButton(static_cast<QAbstractButton*>(button));
}

void QDialogButtonBox_SetCenterButtons(void* ptr, char center)
{
	static_cast<QDialogButtonBox*>(ptr)->setCenterButtons(center != 0);
}

void QDialogButtonBox_SetOrientation(void* ptr, long long orientation)
{
	static_cast<QDialogButtonBox*>(ptr)->setOrientation(static_cast<Qt::Orientation>(orientation));
}

void QDialogButtonBox_SetStandardButtons(void* ptr, long long buttons)
{
	static_cast<QDialogButtonBox*>(ptr)->setStandardButtons(static_cast<QDialogButtonBox::StandardButton>(buttons));
}

long long QDialogButtonBox_StandardButton(void* ptr, void* button)
{
	return static_cast<QDialogButtonBox*>(ptr)->standardButton(static_cast<QAbstractButton*>(button));
}

long long QDialogButtonBox_StandardButtons(void* ptr)
{
	return static_cast<QDialogButtonBox*>(ptr)->standardButtons();
}

void QDialogButtonBox_DestroyQDialogButtonBox(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->~QDialogButtonBox();
}

void QDialogButtonBox_DestroyQDialogButtonBoxDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QDialogButtonBox___buttons_atList(void* ptr, int i)
{
	return ({QAbstractButton * tmp = static_cast<QList<QAbstractButton *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractButton *>*>(ptr)->size()-1) { static_cast<QList<QAbstractButton *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QDialogButtonBox___buttons_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAbstractButton *>();
}

class MyQDirModel: public QDirModel
{
public:
	MyQDirModel(const QStringList &nameFilters, QDir::Filters filters, QDir::SortFlags sort, QObject *parent = Q_NULLPTR) : QDirModel(nameFilters, filters, sort, parent) {QDirModel_QDirModel_QRegisterMetaType();};
	MyQDirModel(QObject *parent = Q_NULLPTR) : QDirModel(parent) {QDirModel_QDirModel_QRegisterMetaType();};
	int columnCount(const QModelIndex & parent) const { return callbackQDirModel_ColumnCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
	QVariant data(const QModelIndex & index, int role) const { return *static_cast<QVariant*>(callbackQDirModel_Data(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), role)); };
	bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQDirModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
	Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQDirModel_Flags(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	bool hasChildren(const QModelIndex & parent) const { return callbackQDirModel_HasChildren(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
	QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQDirModel_HeaderData(const_cast<void*>(static_cast<const void*>(this)), section, orientation, role)); };
	QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQDirModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
	QMimeData * mimeData(const QModelIndexList & indexes) const { return static_cast<QMimeData*>(callbackQDirModel_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QModelIndex>* tmpValuee0adf2 = new QList<QModelIndex>(indexes); QtWidgets_PackedList { tmpValuee0adf2, tmpValuee0adf2->size() }; }))); };
	QStringList mimeTypes() const { return ({ QtWidgets_PackedString tempVal = callbackQDirModel_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	QModelIndex parent(const QModelIndex & child) const { return *static_cast<QModelIndex*>(callbackQDirModel_Parent(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&child))); };
	void refresh(const QModelIndex & parent) { callbackQDirModel_Refresh(this, const_cast<QModelIndex*>(&parent)); };
	int rowCount(const QModelIndex & parent) const { return callbackQDirModel_RowCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
	bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQDirModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
	void sort(int column, Qt::SortOrder order) { callbackQDirModel_Sort(this, column, order); };
	Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQDirModel_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQDirModel() { callbackQDirModel_DestroyQDirModel(this); };
	QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQDirModel_Buddy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQDirModel_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 callbackQDirModel_CanFetchMore(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
	void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last) { callbackQDirModel_ColumnsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn) { callbackQDirModel_ColumnsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationColumn); };
	void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQDirModel_ColumnsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last) { callbackQDirModel_ColumnsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column) { callbackQDirModel_ColumnsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), column); };
	void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last) { callbackQDirModel_ColumnsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_DataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQDirModel_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
	void fetchMore(const QModelIndex & parent) { callbackQDirModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
	void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last) { callbackQDirModel_HeaderDataChanged(this, orientation, first, last); };
	bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQDirModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
	bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQDirModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
	QMap<int, QVariant> itemData(const QModelIndex & index) const { return ({ QMap<int, QVariant>* tmpP = static_cast<QMap<int, QVariant>*>(callbackQDirModel_ItemData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); QMap<int, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }); };
	void Signal_LayoutAboutToBeChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQDirModel_LayoutAboutToBeChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtWidgets_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
	void Signal_LayoutChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQDirModel_LayoutChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtWidgets_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
	QList<QModelIndex> match(const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags) const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQDirModel_Match(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&start), role, const_cast<QVariant*>(&value), hits, flags)); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void Signal_ModelAboutToBeReset() { callbackQDirModel_ModelAboutToBeReset(this); };
	void Signal_ModelReset() { callbackQDirModel_ModelReset(this); };
	bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQDirModel_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 callbackQDirModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
	bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQDirModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
	bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQDirModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
	void resetInternalData() { callbackQDirModel_ResetInternalData(this); };
	void revert() { callbackQDirModel_Revert(this); };
	QHash<int, QByteArray> roleNames() const { return ({ QHash<int, QByteArray>* tmpP = static_cast<QHash<int, QByteArray>*>(callbackQDirModel_RoleNames(const_cast<void*>(static_cast<const void*>(this)))); QHash<int, QByteArray> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; }); };
	void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end) { callbackQDirModel_RowsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow) { callbackQDirModel_RowsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationRow); };
	void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQDirModel_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_RowsInserted(const QModelIndex & parent, int first, int last) { callbackQDirModel_RowsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row) { callbackQDirModel_RowsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), row); };
	void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQDirModel_RowsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
	bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQDirModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
	bool setItemData(const QModelIndex & index, const QMap<int, QVariant> & roles) { return callbackQDirModel_SetItemData(this, const_cast<QModelIndex*>(&index), ({ QMap<int, QVariant>* tmpValue037c88 = new QMap<int, QVariant>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })) != 0; };
	QModelIndex sibling(int row, int column, const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQDirModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&index))); };
	QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQDirModel_Span(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	bool submit() { return callbackQDirModel_Submit(this) != 0; };
	Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQDirModel_SupportedDragActions(const_cast<void*>(static_cast<const void*>(this)))); };
	void childEvent(QChildEvent * event) { callbackQDirModel_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQDirModel_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQDirModel_CustomEvent(this, event); };
	void deleteLater() { callbackQDirModel_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQDirModel_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQDirModel_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQDirModel_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQDirModel_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDirModel_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQDirModel_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQDirModel_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QDirModel*)
Q_DECLARE_METATYPE(MyQDirModel*)

int QDirModel_QDirModel_QRegisterMetaType(){qRegisterMetaType<QDirModel*>(); return qRegisterMetaType<MyQDirModel*>();}

int QDirModel_FilePathRole_Type()
{
	return QDirModel::FilePathRole;
}

void* QDirModel_NewQDirModel(struct QtWidgets_PackedString nameFilters, long long filters, long long sort, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QWindow*>(parent));
	} else {
		return new MyQDirModel(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort), static_cast<QObject*>(parent));
	}
}

void* QDirModel_NewQDirModel2(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQDirModel(static_cast<QWindow*>(parent));
	} else {
		return new MyQDirModel(static_cast<QObject*>(parent));
	}
}

int QDirModel_ColumnCount(void* ptr, void* parent)
{
	return static_cast<QDirModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}

int QDirModel_ColumnCountDefault(void* ptr, void* parent)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::columnCount(*static_cast<QModelIndex*>(parent));
}

void* QDirModel_Data(void* ptr, void* index, int role)
{
	return new QVariant(static_cast<QDirModel*>(ptr)->data(*static_cast<QModelIndex*>(index), role));
}

void* QDirModel_DataDefault(void* ptr, void* index, int role)
{
		return new QVariant(static_cast<QDirModel*>(ptr)->QDirModel::data(*static_cast<QModelIndex*>(index), role));
}

char QDirModel_DropMimeDataDefault(void* ptr, void* data, long long action, int row, int column, void* parent)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}

void* QDirModel_FileIcon(void* ptr, void* index)
{
	return new QIcon(static_cast<QDirModel*>(ptr)->fileIcon(*static_cast<QModelIndex*>(index)));
}

void* QDirModel_FileInfo(void* ptr, void* index)
{
	return new QFileInfo(static_cast<QDirModel*>(ptr)->fileInfo(*static_cast<QModelIndex*>(index)));
}

struct QtWidgets_PackedString QDirModel_FileName(void* ptr, void* index)
{
	return ({ QByteArray* tefae33 = new QByteArray(static_cast<QDirModel*>(ptr)->fileName(*static_cast<QModelIndex*>(index)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tefae33->prepend("WHITESPACE").constData()+10), tefae33->size()-10, tefae33 }; });
}

struct QtWidgets_PackedString QDirModel_FilePath(void* ptr, void* index)
{
	return ({ QByteArray* t327f53 = new QByteArray(static_cast<QDirModel*>(ptr)->filePath(*static_cast<QModelIndex*>(index)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t327f53->prepend("WHITESPACE").constData()+10), t327f53->size()-10, t327f53 }; });
}

long long QDirModel_Filter(void* ptr)
{
	return static_cast<QDirModel*>(ptr)->filter();
}

long long QDirModel_FlagsDefault(void* ptr, void* index)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::flags(*static_cast<QModelIndex*>(index));
}

char QDirModel_HasChildrenDefault(void* ptr, void* parent)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::hasChildren(*static_cast<QModelIndex*>(parent));
}

void* QDirModel_HeaderDataDefault(void* ptr, int section, long long orientation, int role)
{
		return new QVariant(static_cast<QDirModel*>(ptr)->QDirModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
}

void* QDirModel_IconProvider(void* ptr)
{
	return static_cast<QDirModel*>(ptr)->iconProvider();
}

void* QDirModel_Index(void* ptr, int row, int column, void* parent)
{
	return new QModelIndex(static_cast<QDirModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)));
}

void* QDirModel_IndexDefault(void* ptr, int row, int column, void* parent)
{
		return new QModelIndex(static_cast<QDirModel*>(ptr)->QDirModel::index(row, column, *static_cast<QModelIndex*>(parent)));
}

void* QDirModel_Index2(void* ptr, struct QtWidgets_PackedString path, int column)
{
	return new QModelIndex(static_cast<QDirModel*>(ptr)->index(QString::fromUtf8(path.data, path.len), column));
}

char QDirModel_IsDir(void* ptr, void* index)
{
	return static_cast<QDirModel*>(ptr)->isDir(*static_cast<QModelIndex*>(index));
}

char QDirModel_IsReadOnly(void* ptr)
{
	return static_cast<QDirModel*>(ptr)->isReadOnly();
}

char QDirModel_LazyChildCount(void* ptr)
{
	return static_cast<QDirModel*>(ptr)->lazyChildCount();
}

void* QDirModel_MimeDataDefault(void* ptr, void* indexes)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::mimeData(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(indexes); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
}

struct QtWidgets_PackedString QDirModel_MimeTypesDefault(void* ptr)
{
		return ({ QByteArray* td08e24 = new QByteArray(static_cast<QDirModel*>(ptr)->QDirModel::mimeTypes().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(td08e24->prepend("WHITESPACE").constData()+10), td08e24->size()-10, td08e24 }; });
}

void* QDirModel_Mkdir(void* ptr, void* parent, struct QtWidgets_PackedString name)
{
	return new QModelIndex(static_cast<QDirModel*>(ptr)->mkdir(*static_cast<QModelIndex*>(parent), QString::fromUtf8(name.data, name.len)));
}

struct QtWidgets_PackedString QDirModel_NameFilters(void* ptr)
{
	return ({ QByteArray* taf268e = new QByteArray(static_cast<QDirModel*>(ptr)->nameFilters().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(taf268e->prepend("WHITESPACE").constData()+10), taf268e->size()-10, taf268e }; });
}

void* QDirModel_Parent(void* ptr, void* child)
{
	return new QModelIndex(static_cast<QDirModel*>(ptr)->parent(*static_cast<QModelIndex*>(child)));
}

void* QDirModel_ParentDefault(void* ptr, void* child)
{
		return new QModelIndex(static_cast<QDirModel*>(ptr)->QDirModel::parent(*static_cast<QModelIndex*>(child)));
}

void QDirModel_Refresh(void* ptr, void* parent)
{
	QMetaObject::invokeMethod(static_cast<QDirModel*>(ptr), "refresh", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(parent)));
}

void QDirModel_RefreshDefault(void* ptr, void* parent)
{
		static_cast<QDirModel*>(ptr)->QDirModel::refresh(*static_cast<QModelIndex*>(parent));
}

char QDirModel_Remove(void* ptr, void* index)
{
	return static_cast<QDirModel*>(ptr)->remove(*static_cast<QModelIndex*>(index));
}

char QDirModel_ResolveSymlinks(void* ptr)
{
	return static_cast<QDirModel*>(ptr)->resolveSymlinks();
}

char QDirModel_Rmdir(void* ptr, void* index)
{
	return static_cast<QDirModel*>(ptr)->rmdir(*static_cast<QModelIndex*>(index));
}

int QDirModel_RowCount(void* ptr, void* parent)
{
	return static_cast<QDirModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}

int QDirModel_RowCountDefault(void* ptr, void* parent)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::rowCount(*static_cast<QModelIndex*>(parent));
}

char QDirModel_SetDataDefault(void* ptr, void* index, void* value, int role)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::setData(*static_cast<QModelIndex*>(index), *static_cast<QVariant*>(value), role);
}

void QDirModel_SetFilter(void* ptr, long long filters)
{
	static_cast<QDirModel*>(ptr)->setFilter(static_cast<QDir::Filter>(filters));
}

void QDirModel_SetIconProvider(void* ptr, void* provider)
{
	static_cast<QDirModel*>(ptr)->setIconProvider(static_cast<QFileIconProvider*>(provider));
}

void QDirModel_SetLazyChildCount(void* ptr, char enable)
{
	static_cast<QDirModel*>(ptr)->setLazyChildCount(enable != 0);
}

void QDirModel_SetNameFilters(void* ptr, struct QtWidgets_PackedString filters)
{
	static_cast<QDirModel*>(ptr)->setNameFilters(QString::fromUtf8(filters.data, filters.len).split("¡¦!", QString::SkipEmptyParts));
}

void QDirModel_SetReadOnly(void* ptr, char enable)
{
	static_cast<QDirModel*>(ptr)->setReadOnly(enable != 0);
}

void QDirModel_SetResolveSymlinks(void* ptr, char enable)
{
	static_cast<QDirModel*>(ptr)->setResolveSymlinks(enable != 0);
}

void QDirModel_SetSorting(void* ptr, long long sort)
{
	static_cast<QDirModel*>(ptr)->setSorting(static_cast<QDir::SortFlag>(sort));
}

void QDirModel_SortDefault(void* ptr, int column, long long order)
{
		static_cast<QDirModel*>(ptr)->QDirModel::sort(column, static_cast<Qt::SortOrder>(order));
}

long long QDirModel_Sorting(void* ptr)
{
	return static_cast<QDirModel*>(ptr)->sorting();
}

long long QDirModel_SupportedDropActionsDefault(void* ptr)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::supportedDropActions();
}

void QDirModel_DestroyQDirModel(void* ptr)
{
	static_cast<QDirModel*>(ptr)->~QDirModel();
}

void QDirModel_DestroyQDirModelDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QDirModel___mimeData_indexes_atList(void* ptr, int i)
{
	return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QDirModel___mimeData_indexes_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QModelIndex>();
}

void* QDirModel___changePersistentIndexList_from_atList(void* ptr, int i)
{
	return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QDirModel___changePersistentIndexList_from_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QModelIndex>();
}

void* QDirModel___changePersistentIndexList_to_atList(void* ptr, int i)
{
	return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QDirModel___changePersistentIndexList_to_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QModelIndex>();
}

int QDirModel___dataChanged_roles_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QVector<int>*>(ptr)->at(i); if (i == static_cast<QVector<int>*>(ptr)->size()-1) { static_cast<QVector<int>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}

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

void* QDirModel___dataChanged_roles_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<int>();
}

void* QDirModel___itemData_atList(void* ptr, int v, int i)
{
	return new QVariant(({ QVariant tmp = static_cast<QMap<int, QVariant>*>(ptr)->value(v); if (i == static_cast<QMap<int, QVariant>*>(ptr)->size()-1) { static_cast<QMap<int, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QDirModel___itemData_setList(void* ptr, int key, void* i)
{
	static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}

void* QDirModel___itemData_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<int, QVariant>();
}

struct QtWidgets_PackedList QDirModel___itemData_keyList(void* ptr)
{
	return ({ QList<int>* tmpValue249128 = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtWidgets_PackedList { tmpValue249128, tmpValue249128->size() }; });
}

void* QDirModel___layoutAboutToBeChanged_parents_atList(void* ptr, int i)
{
	return new QPersistentModelIndex(({QPersistentModelIndex tmp = static_cast<QList<QPersistentModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QPersistentModelIndex>*>(ptr)->size()-1) { static_cast<QList<QPersistentModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QDirModel___layoutAboutToBeChanged_parents_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QPersistentModelIndex>();
}

void* QDirModel___layoutChanged_parents_atList(void* ptr, int i)
{
	return new QPersistentModelIndex(({QPersistentModelIndex tmp = static_cast<QList<QPersistentModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QPersistentModelIndex>*>(ptr)->size()-1) { static_cast<QList<QPersistentModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QDirModel___layoutChanged_parents_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QPersistentModelIndex>();
}

void* QDirModel___match_atList(void* ptr, int i)
{
	return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QDirModel___match_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QModelIndex>();
}

void* QDirModel___persistentIndexList_atList(void* ptr, int i)
{
	return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QDirModel___persistentIndexList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QModelIndex>();
}

void* QDirModel___roleNames_atList(void* ptr, int v, int i)
{
	return new QByteArray(({ QByteArray tmp = static_cast<QHash<int, QByteArray>*>(ptr)->value(v); if (i == static_cast<QHash<int, QByteArray>*>(ptr)->size()-1) { static_cast<QHash<int, QByteArray>*>(ptr)->~QHash(); free(ptr); }; tmp; }));
}

void QDirModel___roleNames_setList(void* ptr, int key, void* i)
{
	static_cast<QHash<int, QByteArray>*>(ptr)->insert(key, *static_cast<QByteArray*>(i));
}

void* QDirModel___roleNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QHash<int, QByteArray>();
}

struct QtWidgets_PackedList QDirModel___roleNames_keyList(void* ptr)
{
	return ({ QList<int>* tmpValue7fc3bb = new QList<int>(static_cast<QHash<int, QByteArray>*>(ptr)->keys()); QtWidgets_PackedList { tmpValue7fc3bb, tmpValue7fc3bb->size() }; });
}

void* QDirModel___setItemData_roles_atList(void* ptr, int v, int i)
{
	return new QVariant(({ QVariant tmp = static_cast<QMap<int, QVariant>*>(ptr)->value(v); if (i == static_cast<QMap<int, QVariant>*>(ptr)->size()-1) { static_cast<QMap<int, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QDirModel___setItemData_roles_setList(void* ptr, int key, void* i)
{
	static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}

void* QDirModel___setItemData_roles_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<int, QVariant>();
}

struct QtWidgets_PackedList QDirModel___setItemData_roles_keyList(void* ptr)
{
	return ({ QList<int>* tmpValue249128 = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtWidgets_PackedList { tmpValue249128, tmpValue249128->size() }; });
}

int QDirModel_____doSetRoleNames_roleNames_keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

int QDirModel_____itemData_keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

int QDirModel_____roleNames_keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

int QDirModel_____setItemData_roles_keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

int QDirModel_____setRoleNames_roleNames_keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

void* QDirModel___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QDirModel___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QDirModel___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QDirModel___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QDirModel___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QDirModel___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QDirModel___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QDirModel_BuddyDefault(void* ptr, void* index)
{
		return new QModelIndex(static_cast<QDirModel*>(ptr)->QDirModel::buddy(*static_cast<QModelIndex*>(index)));
}

char QDirModel_CanDropMimeDataDefault(void* ptr, void* data, long long action, int row, int column, void* parent)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}

char QDirModel_CanFetchMoreDefault(void* ptr, void* parent)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::canFetchMore(*static_cast<QModelIndex*>(parent));
}

void QDirModel_FetchMoreDefault(void* ptr, void* parent)
{
		static_cast<QDirModel*>(ptr)->QDirModel::fetchMore(*static_cast<QModelIndex*>(parent));
}

char QDirModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
}

char QDirModel_InsertRowsDefault(void* ptr, int row, int count, void* parent)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
}

struct QtWidgets_PackedList QDirModel_ItemDataDefault(void* ptr, void* index)
{
		return ({ QMap<int, QVariant>* tmpValue0139f1 = new QMap<int, QVariant>(static_cast<QDirModel*>(ptr)->QDirModel::itemData(*static_cast<QModelIndex*>(index))); QtWidgets_PackedList { tmpValue0139f1, tmpValue0139f1->size() }; });
}

struct QtWidgets_PackedList QDirModel_MatchDefault(void* ptr, void* start, int role, void* value, int hits, long long flags)
{
		return ({ QList<QModelIndex>* tmpValue725331 = new QList<QModelIndex>(static_cast<QDirModel*>(ptr)->QDirModel::match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtWidgets_PackedList { tmpValue725331, tmpValue725331->size() }; });
}

char QDirModel_MoveColumnsDefault(void* ptr, void* sourceParent, int sourceColumn, int count, void* destinationParent, int destinationChild)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}

char QDirModel_MoveRowsDefault(void* ptr, void* sourceParent, int sourceRow, int count, void* destinationParent, int destinationChild)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}

char QDirModel_RemoveColumnsDefault(void* ptr, int column, int count, void* parent)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
}

char QDirModel_RemoveRowsDefault(void* ptr, int row, int count, void* parent)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
}

void QDirModel_ResetInternalDataDefault(void* ptr)
{
		static_cast<QDirModel*>(ptr)->QDirModel::resetInternalData();
}

void QDirModel_RevertDefault(void* ptr)
{
		static_cast<QDirModel*>(ptr)->QDirModel::revert();
}

struct QtWidgets_PackedList QDirModel_RoleNamesDefault(void* ptr)
{
		return ({ QHash<int, QByteArray>* tmpValue4528f2 = new QHash<int, QByteArray>(static_cast<QDirModel*>(ptr)->QDirModel::roleNames()); QtWidgets_PackedList { tmpValue4528f2, tmpValue4528f2->size() }; });
}

char QDirModel_SetHeaderDataDefault(void* ptr, int section, long long orientation, void* value, int role)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
}

char QDirModel_SetItemDataDefault(void* ptr, void* index, void* roles)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
}

void* QDirModel_SiblingDefault(void* ptr, int row, int column, void* index)
{
		return new QModelIndex(static_cast<QDirModel*>(ptr)->QDirModel::sibling(row, column, *static_cast<QModelIndex*>(index)));
}

void* QDirModel_SpanDefault(void* ptr, void* index)
{
		return ({ QSize tmpValue = static_cast<QDirModel*>(ptr)->QDirModel::span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
}

char QDirModel_SubmitDefault(void* ptr)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::submit();
}

long long QDirModel_SupportedDragActionsDefault(void* ptr)
{
		return static_cast<QDirModel*>(ptr)->QDirModel::supportedDragActions();
}

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

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

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

void QDirModel_DeleteLaterDefault(void* ptr)
{
		static_cast<QDirModel*>(ptr)->QDirModel::deleteLater();
}

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

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

char QDirModel_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QDirModel*>(ptr)->QDirModel::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QDirModel*>(ptr)->QDirModel::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QDirModel*>(ptr)->QDirModel::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QDirModel*>(ptr)->QDirModel::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QDirModel*>(ptr)->QDirModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQDockWidget: public QDockWidget
{
public:
	MyQDockWidget(const QString &title, QWidget *parent = Q_NULLPTR, Qt::WindowFlags flags = Qt::WindowFlags()) : QDockWidget(title, parent, flags) {QDockWidget_QDockWidget_QRegisterMetaType();};
	MyQDockWidget(QWidget *parent = Q_NULLPTR, Qt::WindowFlags flags = Qt::WindowFlags()) : QDockWidget(parent, flags) {QDockWidget_QDockWidget_QRegisterMetaType();};
	void Signal_AllowedAreasChanged(Qt::DockWidgetAreas allowedAreas) { callbackQDockWidget_AllowedAreasChanged(this, allowedAreas); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_DockLocationChanged(Qt::DockWidgetArea area) { callbackQDockWidget_DockLocationChanged(this, area); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void Signal_FeaturesChanged(QDockWidget::DockWidgetFeatures features) { callbackQDockWidget_FeaturesChanged(this, features); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void Signal_TopLevelChanged(bool topLevel) { callbackQDockWidget_TopLevelChanged(this, topLevel); };
	void Signal_VisibilityChanged(bool visible) { callbackQDockWidget_VisibilityChanged(this, visible); };
	 ~MyQDockWidget() { callbackQDockWidget_DestroyQDockWidget(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QDockWidget*)
Q_DECLARE_METATYPE(MyQDockWidget*)

int QDockWidget_QDockWidget_QRegisterMetaType(){qRegisterMetaType<QDockWidget*>(); return qRegisterMetaType<MyQDockWidget*>();}

void* QDockWidget_NewQDockWidget(struct QtWidgets_PackedString title, void* parent, long long flags)
{
		return new MyQDockWidget(QString::fromUtf8(title.data, title.len), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}

void* QDockWidget_NewQDockWidget2(void* parent, long long flags)
{
		return new MyQDockWidget(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}

long long QDockWidget_AllowedAreas(void* ptr)
{
	return static_cast<QDockWidget*>(ptr)->allowedAreas();
}

void QDockWidget_ConnectAllowedAreasChanged(void* ptr, long long t)
{
	qRegisterMetaType<Qt::DockWidgetAreas>();
	QObject::connect(static_cast<QDockWidget*>(ptr), static_cast<void (QDockWidget::*)(Qt::DockWidgetAreas)>(&QDockWidget::allowedAreasChanged), static_cast<MyQDockWidget*>(ptr), static_cast<void (MyQDockWidget::*)(Qt::DockWidgetAreas)>(&MyQDockWidget::Signal_AllowedAreasChanged), static_cast<Qt::ConnectionType>(t));
}

void QDockWidget_DisconnectAllowedAreasChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDockWidget*>(ptr), static_cast<void (QDockWidget::*)(Qt::DockWidgetAreas)>(&QDockWidget::allowedAreasChanged), static_cast<MyQDockWidget*>(ptr), static_cast<void (MyQDockWidget::*)(Qt::DockWidgetAreas)>(&MyQDockWidget::Signal_AllowedAreasChanged));
}

void QDockWidget_AllowedAreasChanged(void* ptr, long long allowedAreas)
{
	static_cast<QDockWidget*>(ptr)->allowedAreasChanged(static_cast<Qt::DockWidgetArea>(allowedAreas));
}

void QDockWidget_ConnectDockLocationChanged(void* ptr, long long t)
{
	qRegisterMetaType<Qt::DockWidgetArea>();
	QObject::connect(static_cast<QDockWidget*>(ptr), static_cast<void (QDockWidget::*)(Qt::DockWidgetArea)>(&QDockWidget::dockLocationChanged), static_cast<MyQDockWidget*>(ptr), static_cast<void (MyQDockWidget::*)(Qt::DockWidgetArea)>(&MyQDockWidget::Signal_DockLocationChanged), static_cast<Qt::ConnectionType>(t));
}

void QDockWidget_DisconnectDockLocationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDockWidget*>(ptr), static_cast<void (QDockWidget::*)(Qt::DockWidgetArea)>(&QDockWidget::dockLocationChanged), static_cast<MyQDockWidget*>(ptr), static_cast<void (MyQDockWidget::*)(Qt::DockWidgetArea)>(&MyQDockWidget::Signal_DockLocationChanged));
}

void QDockWidget_DockLocationChanged(void* ptr, long long area)
{
	static_cast<QDockWidget*>(ptr)->dockLocationChanged(static_cast<Qt::DockWidgetArea>(area));
}

long long QDockWidget_Features(void* ptr)
{
	return static_cast<QDockWidget*>(ptr)->features();
}

void QDockWidget_ConnectFeaturesChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QDockWidget*>(ptr), static_cast<void (QDockWidget::*)(QDockWidget::DockWidgetFeatures)>(&QDockWidget::featuresChanged), static_cast<MyQDockWidget*>(ptr), static_cast<void (MyQDockWidget::*)(QDockWidget::DockWidgetFeatures)>(&MyQDockWidget::Signal_FeaturesChanged), static_cast<Qt::ConnectionType>(t));
}

void QDockWidget_DisconnectFeaturesChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDockWidget*>(ptr), static_cast<void (QDockWidget::*)(QDockWidget::DockWidgetFeatures)>(&QDockWidget::featuresChanged), static_cast<MyQDockWidget*>(ptr), static_cast<void (MyQDockWidget::*)(QDockWidget::DockWidgetFeatures)>(&MyQDockWidget::Signal_FeaturesChanged));
}

void QDockWidget_FeaturesChanged(void* ptr, long long features)
{
	static_cast<QDockWidget*>(ptr)->featuresChanged(static_cast<QDockWidget::DockWidgetFeature>(features));
}

void QDockWidget_InitStyleOption(void* ptr, void* option)
{
	static_cast<QDockWidget*>(ptr)->initStyleOption(static_cast<QStyleOptionDockWidget*>(option));
}

char QDockWidget_IsAreaAllowed(void* ptr, long long area)
{
	return static_cast<QDockWidget*>(ptr)->isAreaAllowed(static_cast<Qt::DockWidgetArea>(area));
}

char QDockWidget_IsFloating(void* ptr)
{
	return static_cast<QDockWidget*>(ptr)->isFloating();
}

void QDockWidget_SetAllowedAreas(void* ptr, long long areas)
{
	static_cast<QDockWidget*>(ptr)->setAllowedAreas(static_cast<Qt::DockWidgetArea>(areas));
}

void QDockWidget_SetFeatures(void* ptr, long long features)
{
	static_cast<QDockWidget*>(ptr)->setFeatures(static_cast<QDockWidget::DockWidgetFeature>(features));
}

void QDockWidget_SetFloating(void* ptr, char floating)
{
	static_cast<QDockWidget*>(ptr)->setFloating(floating != 0);
}

void QDockWidget_SetTitleBarWidget(void* ptr, void* widget)
{
		static_cast<QDockWidget*>(ptr)->setTitleBarWidget(static_cast<QWidget*>(widget));
}

void QDockWidget_SetWidget(void* ptr, void* widget)
{
		static_cast<QDockWidget*>(ptr)->setWidget(static_cast<QWidget*>(widget));
}

void* QDockWidget_TitleBarWidget(void* ptr)
{
	return static_cast<QDockWidget*>(ptr)->titleBarWidget();
}

void* QDockWidget_ToggleViewAction(void* ptr)
{
	return static_cast<QDockWidget*>(ptr)->toggleViewAction();
}

void QDockWidget_ConnectTopLevelChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QDockWidget*>(ptr), static_cast<void (QDockWidget::*)(bool)>(&QDockWidget::topLevelChanged), static_cast<MyQDockWidget*>(ptr), static_cast<void (MyQDockWidget::*)(bool)>(&MyQDockWidget::Signal_TopLevelChanged), static_cast<Qt::ConnectionType>(t));
}

void QDockWidget_DisconnectTopLevelChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDockWidget*>(ptr), static_cast<void (QDockWidget::*)(bool)>(&QDockWidget::topLevelChanged), static_cast<MyQDockWidget*>(ptr), static_cast<void (MyQDockWidget::*)(bool)>(&MyQDockWidget::Signal_TopLevelChanged));
}

void QDockWidget_TopLevelChanged(void* ptr, char topLevel)
{
	static_cast<QDockWidget*>(ptr)->topLevelChanged(topLevel != 0);
}

void QDockWidget_ConnectVisibilityChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QDockWidget*>(ptr), static_cast<void (QDockWidget::*)(bool)>(&QDockWidget::visibilityChanged), static_cast<MyQDockWidget*>(ptr), static_cast<void (MyQDockWidget::*)(bool)>(&MyQDockWidget::Signal_VisibilityChanged), static_cast<Qt::ConnectionType>(t));
}

void QDockWidget_DisconnectVisibilityChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDockWidget*>(ptr), static_cast<void (QDockWidget::*)(bool)>(&QDockWidget::visibilityChanged), static_cast<MyQDockWidget*>(ptr), static_cast<void (MyQDockWidget::*)(bool)>(&MyQDockWidget::Signal_VisibilityChanged));
}

void QDockWidget_VisibilityChanged(void* ptr, char visible)
{
	static_cast<QDockWidget*>(ptr)->visibilityChanged(visible != 0);
}

void* QDockWidget_Widget(void* ptr)
{
	return static_cast<QDockWidget*>(ptr)->widget();
}

void QDockWidget_DestroyQDockWidget(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->~QDockWidget();
}

void QDockWidget_DestroyQDockWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQDoubleSpinBox: public QDoubleSpinBox
{
public:
	MyQDoubleSpinBox(QWidget *parent = Q_NULLPTR) : QDoubleSpinBox(parent) {QDoubleSpinBox_QDoubleSpinBox_QRegisterMetaType();};
	void fixup(QString & input) const { QByteArray* t140f86 = new QByteArray(input.toUtf8()); QtWidgets_PackedString inputPacked = { const_cast<char*>(t140f86->prepend("WHITESPACE").constData()+10), t140f86->size()-10, t140f86 };callbackQAbstractSpinBox_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
	void setValue(double val) { callbackQDoubleSpinBox_SetValue(this, val); };
	QString textFromValue(double value) const { return ({ QtWidgets_PackedString tempVal = callbackQDoubleSpinBox_TextFromValue(const_cast<void*>(static_cast<const void*>(this)), value); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	QValidator::State validate(QString & text, int & pos) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };return static_cast<QValidator::State>(callbackQAbstractSpinBox_Validate(const_cast<void*>(static_cast<const void*>(this)), textPacked, pos)); };
	void Signal_ValueChanged(double d) { callbackQDoubleSpinBox_ValueChanged(this, d); };
	void Signal_ValueChanged2(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQDoubleSpinBox_ValueChanged2(this, textPacked); };
	double valueFromText(const QString & text) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };return callbackQDoubleSpinBox_ValueFromText(const_cast<void*>(static_cast<const void*>(this)), textPacked); };
	 ~MyQDoubleSpinBox() { callbackQDoubleSpinBox_DestroyQDoubleSpinBox(this); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	void clear() { callbackQAbstractSpinBox_Clear(this); };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_EditingFinished() { callbackQAbstractSpinBox_EditingFinished(this); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void selectAll() { callbackQAbstractSpinBox_SelectAll(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void stepBy(int steps) { callbackQAbstractSpinBox_StepBy(this, steps); };
	void stepDown() { callbackQAbstractSpinBox_StepDown(this); };
	QAbstractSpinBox::StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQAbstractSpinBox_StepEnabled(const_cast<void*>(static_cast<const void*>(this)))); };
	void stepUp() { callbackQAbstractSpinBox_StepUp(this); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QDoubleSpinBox*)
Q_DECLARE_METATYPE(MyQDoubleSpinBox*)

int QDoubleSpinBox_QDoubleSpinBox_QRegisterMetaType(){qRegisterMetaType<QDoubleSpinBox*>(); return qRegisterMetaType<MyQDoubleSpinBox*>();}

void* QDoubleSpinBox_NewQDoubleSpinBox(void* parent)
{
		return new MyQDoubleSpinBox(static_cast<QWidget*>(parent));
}

struct QtWidgets_PackedString QDoubleSpinBox_CleanText(void* ptr)
{
	return ({ QByteArray* t77d32e = new QByteArray(static_cast<QDoubleSpinBox*>(ptr)->cleanText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t77d32e->prepend("WHITESPACE").constData()+10), t77d32e->size()-10, t77d32e }; });
}

int QDoubleSpinBox_Decimals(void* ptr)
{
	return static_cast<QDoubleSpinBox*>(ptr)->decimals();
}

double QDoubleSpinBox_Maximum(void* ptr)
{
	return static_cast<QDoubleSpinBox*>(ptr)->maximum();
}

double QDoubleSpinBox_Minimum(void* ptr)
{
	return static_cast<QDoubleSpinBox*>(ptr)->minimum();
}

struct QtWidgets_PackedString QDoubleSpinBox_Prefix(void* ptr)
{
	return ({ QByteArray* t5a79ac = new QByteArray(static_cast<QDoubleSpinBox*>(ptr)->prefix().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t5a79ac->prepend("WHITESPACE").constData()+10), t5a79ac->size()-10, t5a79ac }; });
}

void QDoubleSpinBox_SetDecimals(void* ptr, int prec)
{
	static_cast<QDoubleSpinBox*>(ptr)->setDecimals(prec);
}

void QDoubleSpinBox_SetMaximum(void* ptr, double max)
{
	static_cast<QDoubleSpinBox*>(ptr)->setMaximum(max);
}

void QDoubleSpinBox_SetMinimum(void* ptr, double min)
{
	static_cast<QDoubleSpinBox*>(ptr)->setMinimum(min);
}

void QDoubleSpinBox_SetPrefix(void* ptr, struct QtWidgets_PackedString prefix)
{
	static_cast<QDoubleSpinBox*>(ptr)->setPrefix(QString::fromUtf8(prefix.data, prefix.len));
}

void QDoubleSpinBox_SetRange(void* ptr, double minimum, double maximum)
{
	static_cast<QDoubleSpinBox*>(ptr)->setRange(minimum, maximum);
}

void QDoubleSpinBox_SetSingleStep(void* ptr, double val)
{
	static_cast<QDoubleSpinBox*>(ptr)->setSingleStep(val);
}

void QDoubleSpinBox_SetStepType(void* ptr, long long stepType)
{
	static_cast<QDoubleSpinBox*>(ptr)->setStepType(static_cast<QAbstractSpinBox::StepType>(stepType));
}

void QDoubleSpinBox_SetSuffix(void* ptr, struct QtWidgets_PackedString suffix)
{
	static_cast<QDoubleSpinBox*>(ptr)->setSuffix(QString::fromUtf8(suffix.data, suffix.len));
}

void QDoubleSpinBox_SetValue(void* ptr, double val)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setValue", Q_ARG(double, val));
}

void QDoubleSpinBox_SetValueDefault(void* ptr, double val)
{
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setValue(val);
}

double QDoubleSpinBox_SingleStep(void* ptr)
{
	return static_cast<QDoubleSpinBox*>(ptr)->singleStep();
}

long long QDoubleSpinBox_StepType(void* ptr)
{
	return static_cast<QDoubleSpinBox*>(ptr)->stepType();
}

struct QtWidgets_PackedString QDoubleSpinBox_Suffix(void* ptr)
{
	return ({ QByteArray* t4d98e3 = new QByteArray(static_cast<QDoubleSpinBox*>(ptr)->suffix().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t4d98e3->prepend("WHITESPACE").constData()+10), t4d98e3->size()-10, t4d98e3 }; });
}

struct QtWidgets_PackedString QDoubleSpinBox_TextFromValue(void* ptr, double value)
{
	return ({ QByteArray* t86f376 = new QByteArray(static_cast<QDoubleSpinBox*>(ptr)->textFromValue(value).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t86f376->prepend("WHITESPACE").constData()+10), t86f376->size()-10, t86f376 }; });
}

struct QtWidgets_PackedString QDoubleSpinBox_TextFromValueDefault(void* ptr, double value)
{
		return ({ QByteArray* t7bc6a7 = new QByteArray(static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::textFromValue(value).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t7bc6a7->prepend("WHITESPACE").constData()+10), t7bc6a7->size()-10, t7bc6a7 }; });
}

double QDoubleSpinBox_Value(void* ptr)
{
	return static_cast<QDoubleSpinBox*>(ptr)->value();
}

void QDoubleSpinBox_ConnectValueChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QDoubleSpinBox*>(ptr), static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), static_cast<MyQDoubleSpinBox*>(ptr), static_cast<void (MyQDoubleSpinBox::*)(double)>(&MyQDoubleSpinBox::Signal_ValueChanged), static_cast<Qt::ConnectionType>(t));
}

void QDoubleSpinBox_DisconnectValueChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDoubleSpinBox*>(ptr), static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), static_cast<MyQDoubleSpinBox*>(ptr), static_cast<void (MyQDoubleSpinBox::*)(double)>(&MyQDoubleSpinBox::Signal_ValueChanged));
}

void QDoubleSpinBox_ValueChanged(void* ptr, double d)
{
	static_cast<QDoubleSpinBox*>(ptr)->valueChanged(d);
}

void QDoubleSpinBox_ConnectValueChanged2(void* ptr, long long t)
{
	QObject::connect(static_cast<QDoubleSpinBox*>(ptr), static_cast<void (QDoubleSpinBox::*)(const QString &)>(&QDoubleSpinBox::valueChanged), static_cast<MyQDoubleSpinBox*>(ptr), static_cast<void (MyQDoubleSpinBox::*)(const QString &)>(&MyQDoubleSpinBox::Signal_ValueChanged2), static_cast<Qt::ConnectionType>(t));
}

void QDoubleSpinBox_DisconnectValueChanged2(void* ptr)
{
	QObject::disconnect(static_cast<QDoubleSpinBox*>(ptr), static_cast<void (QDoubleSpinBox::*)(const QString &)>(&QDoubleSpinBox::valueChanged), static_cast<MyQDoubleSpinBox*>(ptr), static_cast<void (MyQDoubleSpinBox::*)(const QString &)>(&MyQDoubleSpinBox::Signal_ValueChanged2));
}

void QDoubleSpinBox_ValueChanged2(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QDoubleSpinBox*>(ptr)->valueChanged(QString::fromUtf8(text.data, text.len));
}

double QDoubleSpinBox_ValueFromText(void* ptr, struct QtWidgets_PackedString text)
{
	return static_cast<QDoubleSpinBox*>(ptr)->valueFromText(QString::fromUtf8(text.data, text.len));
}

double QDoubleSpinBox_ValueFromTextDefault(void* ptr, struct QtWidgets_PackedString text)
{
		return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::valueFromText(QString::fromUtf8(text.data, text.len));
}

void QDoubleSpinBox_DestroyQDoubleSpinBox(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->~QDoubleSpinBox();
}

void QDoubleSpinBox_DestroyQDoubleSpinBoxDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQErrorMessage: public QErrorMessage
{
public:
	MyQErrorMessage(QWidget *parent = Q_NULLPTR) : QErrorMessage(parent) {QErrorMessage_QErrorMessage_QRegisterMetaType();};
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void done(int a) { callbackQErrorMessage_Done(this, a); };
	void showMessage(const QString & message) { QByteArray* t6f9b9a = new QByteArray(message.toUtf8()); QtWidgets_PackedString messagePacked = { const_cast<char*>(t6f9b9a->prepend("WHITESPACE").constData()+10), t6f9b9a->size()-10, t6f9b9a };callbackQErrorMessage_ShowMessage(this, messagePacked); };
	void showMessage(const QString & message, const QString & ty) { QByteArray* t6f9b9a = new QByteArray(message.toUtf8()); QtWidgets_PackedString messagePacked = { const_cast<char*>(t6f9b9a->prepend("WHITESPACE").constData()+10), t6f9b9a->size()-10, t6f9b9a };QByteArray* td0a3e7 = new QByteArray(ty.toUtf8()); QtWidgets_PackedString tyPacked = { const_cast<char*>(td0a3e7->prepend("WHITESPACE").constData()+10), td0a3e7->size()-10, td0a3e7 };callbackQErrorMessage_ShowMessage2(this, messagePacked, tyPacked); };
	 ~MyQErrorMessage() { callbackQErrorMessage_DestroyQErrorMessage(this); };
	void accept() { callbackQDialog_Accept(this); };
	void Signal_Accepted() { callbackQDialog_Accepted(this); };
	void closeEvent(QCloseEvent * e) { callbackQWidget_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	bool eventFilter(QObject * o, QEvent * e) { return callbackQWidget_EventFilter(this, o, e) != 0; };
	int exec() { return callbackQDialog_Exec(this); };
	void Signal_Finished(int result) { callbackQDialog_Finished(this, result); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void open() { callbackQDialog_Open(this); };
	void reject() { callbackQDialog_Reject(this); };
	void Signal_Rejected() { callbackQDialog_Rejected(this); };
	void resizeEvent(QResizeEvent * vqr) { callbackQWidget_ResizeEvent(this, vqr); };
	void setVisible(bool visible) { callbackQDialog_SetVisible(this, visible); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QErrorMessage*)
Q_DECLARE_METATYPE(MyQErrorMessage*)

int QErrorMessage_QErrorMessage_QRegisterMetaType(){qRegisterMetaType<QErrorMessage*>(); return qRegisterMetaType<MyQErrorMessage*>();}

void* QErrorMessage_NewQErrorMessage(void* parent)
{
		return new MyQErrorMessage(static_cast<QWidget*>(parent));
}

void QErrorMessage_Done(void* ptr, int a)
{
	static_cast<QErrorMessage*>(ptr)->done(a);
}

void QErrorMessage_DoneDefault(void* ptr, int a)
{
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::done(a);
}

void* QErrorMessage_QErrorMessage_QtHandler()
{
	return QErrorMessage::qtHandler();
}

void QErrorMessage_ShowMessage(void* ptr, struct QtWidgets_PackedString message)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "showMessage", Q_ARG(const QString, QString::fromUtf8(message.data, message.len)));
}

void QErrorMessage_ShowMessageDefault(void* ptr, struct QtWidgets_PackedString message)
{
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::showMessage(QString::fromUtf8(message.data, message.len));
}

void QErrorMessage_ShowMessage2(void* ptr, struct QtWidgets_PackedString message, struct QtWidgets_PackedString ty)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "showMessage", Q_ARG(const QString, QString::fromUtf8(message.data, message.len)), Q_ARG(const QString, QString::fromUtf8(ty.data, ty.len)));
}

void QErrorMessage_ShowMessage2Default(void* ptr, struct QtWidgets_PackedString message, struct QtWidgets_PackedString ty)
{
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::showMessage(QString::fromUtf8(message.data, message.len), QString::fromUtf8(ty.data, ty.len));
}

void QErrorMessage_DestroyQErrorMessage(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->~QErrorMessage();
}

void QErrorMessage_DestroyQErrorMessageDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQFileDialog: public QFileDialog
{
public:
	MyQFileDialog(QWidget *parent, Qt::WindowFlags flags) : QFileDialog(parent, flags) {QFileDialog_QFileDialog_QRegisterMetaType();};
	MyQFileDialog(QWidget *parent = Q_NULLPTR, const QString &caption = QString(), const QString &directory = QString(), const QString &filter = QString()) : QFileDialog(parent, caption, directory, filter) {QFileDialog_QFileDialog_QRegisterMetaType();};
	void accept() { callbackQFileDialog_Accept(this); };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void Signal_CurrentChanged(const QString & path) { QByteArray* t3150ec = new QByteArray(path.toUtf8()); QtWidgets_PackedString pathPacked = { const_cast<char*>(t3150ec->prepend("WHITESPACE").constData()+10), t3150ec->size()-10, t3150ec };callbackQFileDialog_CurrentChanged(this, pathPacked); };
	void Signal_CurrentUrlChanged(const QUrl & url) { callbackQFileDialog_CurrentUrlChanged(this, const_cast<QUrl*>(&url)); };
	void Signal_DirectoryEntered(const QString & directory) { QByteArray* t8d392f = new QByteArray(directory.toUtf8()); QtWidgets_PackedString directoryPacked = { const_cast<char*>(t8d392f->prepend("WHITESPACE").constData()+10), t8d392f->size()-10, t8d392f };callbackQFileDialog_DirectoryEntered(this, directoryPacked); };
	void Signal_DirectoryUrlEntered(const QUrl & directory) { callbackQFileDialog_DirectoryUrlEntered(this, const_cast<QUrl*>(&directory)); };
	void done(int result) { callbackQFileDialog_Done(this, result); };
	void Signal_FileSelected(const QString & file) { QByteArray* t971c41 = new QByteArray(file.toUtf8()); QtWidgets_PackedString filePacked = { const_cast<char*>(t971c41->prepend("WHITESPACE").constData()+10), t971c41->size()-10, t971c41 };callbackQFileDialog_FileSelected(this, filePacked); };
	void Signal_FilesSelected(const QStringList & selected) { QByteArray* t835f3b = new QByteArray(selected.join("¡¦!").toUtf8()); QtWidgets_PackedString selectedPacked = { const_cast<char*>(t835f3b->prepend("WHITESPACE").constData()+10), t835f3b->size()-10, t835f3b };callbackQFileDialog_FilesSelected(this, selectedPacked); };
	void Signal_FilterSelected(const QString & filter) { QByteArray* t4bb4ca = new QByteArray(filter.toUtf8()); QtWidgets_PackedString filterPacked = { const_cast<char*>(t4bb4ca->prepend("WHITESPACE").constData()+10), t4bb4ca->size()-10, t4bb4ca };callbackQFileDialog_FilterSelected(this, filterPacked); };
	void setVisible(bool visible) { callbackQDialog_SetVisible(this, visible); };
	void Signal_UrlSelected(const QUrl & url) { callbackQFileDialog_UrlSelected(this, const_cast<QUrl*>(&url)); };
	void Signal_UrlsSelected(const QList<QUrl> & urls) { callbackQFileDialog_UrlsSelected(this, ({ QList<QUrl>* tmpValuec9856c = new QList<QUrl>(urls); QtWidgets_PackedList { tmpValuec9856c, tmpValuec9856c->size() }; })); };
	 ~MyQFileDialog() { callbackQFileDialog_DestroyQFileDialog(this); };
	void Signal_Accepted() { callbackQDialog_Accepted(this); };
	void closeEvent(QCloseEvent * e) { callbackQWidget_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	bool eventFilter(QObject * o, QEvent * e) { return callbackQWidget_EventFilter(this, o, e) != 0; };
	int exec() { return callbackQDialog_Exec(this); };
	void Signal_Finished(int result) { callbackQDialog_Finished(this, result); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void reject() { callbackQDialog_Reject(this); };
	void Signal_Rejected() { callbackQDialog_Rejected(this); };
	void resizeEvent(QResizeEvent * vqr) { callbackQWidget_ResizeEvent(this, vqr); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QFileDialog*)
Q_DECLARE_METATYPE(MyQFileDialog*)

int QFileDialog_QFileDialog_QRegisterMetaType(){qRegisterMetaType<QFileDialog*>(); return qRegisterMetaType<MyQFileDialog*>();}

void* QFileDialog_NewQFileDialog(void* parent, long long flags)
{
		return new MyQFileDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}

void* QFileDialog_NewQFileDialog2(void* parent, struct QtWidgets_PackedString caption, struct QtWidgets_PackedString directory, struct QtWidgets_PackedString filter)
{
		return new MyQFileDialog(static_cast<QWidget*>(parent), QString::fromUtf8(caption.data, caption.len), QString::fromUtf8(directory.data, directory.len), QString::fromUtf8(filter.data, filter.len));
}

void QFileDialog_Accept(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->accept();
}

void QFileDialog_AcceptDefault(void* ptr)
{
		static_cast<QFileDialog*>(ptr)->QFileDialog::accept();
}

long long QFileDialog_AcceptMode(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->acceptMode();
}

char QFileDialog_ConfirmOverwrite(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->confirmOverwrite();
}

void QFileDialog_ConnectCurrentChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QString &)>(&QFileDialog::currentChanged), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QString &)>(&MyQFileDialog::Signal_CurrentChanged), static_cast<Qt::ConnectionType>(t));
}

void QFileDialog_DisconnectCurrentChanged(void* ptr)
{
	QObject::disconnect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QString &)>(&QFileDialog::currentChanged), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QString &)>(&MyQFileDialog::Signal_CurrentChanged));
}

void QFileDialog_CurrentChanged(void* ptr, struct QtWidgets_PackedString path)
{
	static_cast<QFileDialog*>(ptr)->currentChanged(QString::fromUtf8(path.data, path.len));
}

void QFileDialog_ConnectCurrentUrlChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QUrl &)>(&QFileDialog::currentUrlChanged), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QUrl &)>(&MyQFileDialog::Signal_CurrentUrlChanged), static_cast<Qt::ConnectionType>(t));
}

void QFileDialog_DisconnectCurrentUrlChanged(void* ptr)
{
	QObject::disconnect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QUrl &)>(&QFileDialog::currentUrlChanged), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QUrl &)>(&MyQFileDialog::Signal_CurrentUrlChanged));
}

void QFileDialog_CurrentUrlChanged(void* ptr, void* url)
{
	static_cast<QFileDialog*>(ptr)->currentUrlChanged(*static_cast<QUrl*>(url));
}

struct QtWidgets_PackedString QFileDialog_DefaultSuffix(void* ptr)
{
	return ({ QByteArray* t9b6b68 = new QByteArray(static_cast<QFileDialog*>(ptr)->defaultSuffix().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t9b6b68->prepend("WHITESPACE").constData()+10), t9b6b68->size()-10, t9b6b68 }; });
}

void* QFileDialog_Directory(void* ptr)
{
	return new QDir(static_cast<QFileDialog*>(ptr)->directory());
}

void QFileDialog_ConnectDirectoryEntered(void* ptr, long long t)
{
	QObject::connect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QString &)>(&QFileDialog::directoryEntered), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QString &)>(&MyQFileDialog::Signal_DirectoryEntered), static_cast<Qt::ConnectionType>(t));
}

void QFileDialog_DisconnectDirectoryEntered(void* ptr)
{
	QObject::disconnect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QString &)>(&QFileDialog::directoryEntered), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QString &)>(&MyQFileDialog::Signal_DirectoryEntered));
}

void QFileDialog_DirectoryEntered(void* ptr, struct QtWidgets_PackedString directory)
{
	static_cast<QFileDialog*>(ptr)->directoryEntered(QString::fromUtf8(directory.data, directory.len));
}

void* QFileDialog_DirectoryUrl(void* ptr)
{
	return new QUrl(static_cast<QFileDialog*>(ptr)->directoryUrl());
}

void QFileDialog_ConnectDirectoryUrlEntered(void* ptr, long long t)
{
	QObject::connect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QUrl &)>(&QFileDialog::directoryUrlEntered), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QUrl &)>(&MyQFileDialog::Signal_DirectoryUrlEntered), static_cast<Qt::ConnectionType>(t));
}

void QFileDialog_DisconnectDirectoryUrlEntered(void* ptr)
{
	QObject::disconnect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QUrl &)>(&QFileDialog::directoryUrlEntered), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QUrl &)>(&MyQFileDialog::Signal_DirectoryUrlEntered));
}

void QFileDialog_DirectoryUrlEntered(void* ptr, void* directory)
{
	static_cast<QFileDialog*>(ptr)->directoryUrlEntered(*static_cast<QUrl*>(directory));
}

void QFileDialog_Done(void* ptr, int result)
{
	static_cast<QFileDialog*>(ptr)->done(result);
}

void QFileDialog_DoneDefault(void* ptr, int result)
{
		static_cast<QFileDialog*>(ptr)->QFileDialog::done(result);
}

long long QFileDialog_FileMode(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->fileMode();
}

void QFileDialog_ConnectFileSelected(void* ptr, long long t)
{
	QObject::connect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QString &)>(&QFileDialog::fileSelected), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QString &)>(&MyQFileDialog::Signal_FileSelected), static_cast<Qt::ConnectionType>(t));
}

void QFileDialog_DisconnectFileSelected(void* ptr)
{
	QObject::disconnect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QString &)>(&QFileDialog::fileSelected), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QString &)>(&MyQFileDialog::Signal_FileSelected));
}

void QFileDialog_FileSelected(void* ptr, struct QtWidgets_PackedString file)
{
	static_cast<QFileDialog*>(ptr)->fileSelected(QString::fromUtf8(file.data, file.len));
}

void QFileDialog_ConnectFilesSelected(void* ptr, long long t)
{
	QObject::connect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QStringList &)>(&QFileDialog::filesSelected), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QStringList &)>(&MyQFileDialog::Signal_FilesSelected), static_cast<Qt::ConnectionType>(t));
}

void QFileDialog_DisconnectFilesSelected(void* ptr)
{
	QObject::disconnect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QStringList &)>(&QFileDialog::filesSelected), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QStringList &)>(&MyQFileDialog::Signal_FilesSelected));
}

void QFileDialog_FilesSelected(void* ptr, struct QtWidgets_PackedString selected)
{
	static_cast<QFileDialog*>(ptr)->filesSelected(QString::fromUtf8(selected.data, selected.len).split("¡¦!", QString::SkipEmptyParts));
}

long long QFileDialog_Filter(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->filter();
}

void QFileDialog_ConnectFilterSelected(void* ptr, long long t)
{
	QObject::connect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QString &)>(&QFileDialog::filterSelected), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QString &)>(&MyQFileDialog::Signal_FilterSelected), static_cast<Qt::ConnectionType>(t));
}

void QFileDialog_DisconnectFilterSelected(void* ptr)
{
	QObject::disconnect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QString &)>(&QFileDialog::filterSelected), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QString &)>(&MyQFileDialog::Signal_FilterSelected));
}

void QFileDialog_FilterSelected(void* ptr, struct QtWidgets_PackedString filter)
{
	static_cast<QFileDialog*>(ptr)->filterSelected(QString::fromUtf8(filter.data, filter.len));
}

struct QtWidgets_PackedString QFileDialog_QFileDialog_GetExistingDirectory(void* parent, struct QtWidgets_PackedString caption, struct QtWidgets_PackedString dir, long long options)
{
		return ({ QByteArray* t875e51 = new QByteArray(QFileDialog::getExistingDirectory(static_cast<QWidget*>(parent), QString::fromUtf8(caption.data, caption.len), QString::fromUtf8(dir.data, dir.len), static_cast<QFileDialog::Option>(options)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t875e51->prepend("WHITESPACE").constData()+10), t875e51->size()-10, t875e51 }; });
}

void* QFileDialog_QFileDialog_GetExistingDirectoryUrl(void* parent, struct QtWidgets_PackedString caption, void* dir, long long options, struct QtWidgets_PackedString supportedSchemes)
{
		return new QUrl(QFileDialog::getExistingDirectoryUrl(static_cast<QWidget*>(parent), QString::fromUtf8(caption.data, caption.len), *static_cast<QUrl*>(dir), static_cast<QFileDialog::Option>(options), QString::fromUtf8(supportedSchemes.data, supportedSchemes.len).split("¡¦!", QString::SkipEmptyParts)));
}

struct QtWidgets_PackedString QFileDialog_QFileDialog_GetOpenFileName(void* parent, struct QtWidgets_PackedString caption, struct QtWidgets_PackedString dir, struct QtWidgets_PackedString filter, struct QtWidgets_PackedString selectedFilter, long long options)
{
		return ({ QByteArray* t2c631a = new QByteArray(QFileDialog::getOpenFileName(static_cast<QWidget*>(parent), QString::fromUtf8(caption.data, caption.len), QString::fromUtf8(dir.data, dir.len), QString::fromUtf8(filter.data, filter.len), new QString(QString::fromUtf8(selectedFilter.data, selectedFilter.len)), static_cast<QFileDialog::Option>(options)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t2c631a->prepend("WHITESPACE").constData()+10), t2c631a->size()-10, t2c631a }; });
}

struct QtWidgets_PackedString QFileDialog_QFileDialog_GetOpenFileNames(void* parent, struct QtWidgets_PackedString caption, struct QtWidgets_PackedString dir, struct QtWidgets_PackedString filter, struct QtWidgets_PackedString selectedFilter, long long options)
{
		return ({ QByteArray* t77ac08 = new QByteArray(QFileDialog::getOpenFileNames(static_cast<QWidget*>(parent), QString::fromUtf8(caption.data, caption.len), QString::fromUtf8(dir.data, dir.len), QString::fromUtf8(filter.data, filter.len), new QString(QString::fromUtf8(selectedFilter.data, selectedFilter.len)), static_cast<QFileDialog::Option>(options)).join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t77ac08->prepend("WHITESPACE").constData()+10), t77ac08->size()-10, t77ac08 }; });
}

void* QFileDialog_QFileDialog_GetOpenFileUrl(void* parent, struct QtWidgets_PackedString caption, void* dir, struct QtWidgets_PackedString filter, struct QtWidgets_PackedString selectedFilter, long long options, struct QtWidgets_PackedString supportedSchemes)
{
		return new QUrl(QFileDialog::getOpenFileUrl(static_cast<QWidget*>(parent), QString::fromUtf8(caption.data, caption.len), *static_cast<QUrl*>(dir), QString::fromUtf8(filter.data, filter.len), new QString(QString::fromUtf8(selectedFilter.data, selectedFilter.len)), static_cast<QFileDialog::Option>(options), QString::fromUtf8(supportedSchemes.data, supportedSchemes.len).split("¡¦!", QString::SkipEmptyParts)));
}

struct QtWidgets_PackedList QFileDialog_QFileDialog_GetOpenFileUrls(void* parent, struct QtWidgets_PackedString caption, void* dir, struct QtWidgets_PackedString filter, struct QtWidgets_PackedString selectedFilter, long long options, struct QtWidgets_PackedString supportedSchemes)
{
		return ({ QList<QUrl>* tmpValue688015 = new QList<QUrl>(QFileDialog::getOpenFileUrls(static_cast<QWidget*>(parent), QString::fromUtf8(caption.data, caption.len), *static_cast<QUrl*>(dir), QString::fromUtf8(filter.data, filter.len), new QString(QString::fromUtf8(selectedFilter.data, selectedFilter.len)), static_cast<QFileDialog::Option>(options), QString::fromUtf8(supportedSchemes.data, supportedSchemes.len).split("¡¦!", QString::SkipEmptyParts))); QtWidgets_PackedList { tmpValue688015, tmpValue688015->size() }; });
}

struct QtWidgets_PackedString QFileDialog_QFileDialog_GetSaveFileName(void* parent, struct QtWidgets_PackedString caption, struct QtWidgets_PackedString dir, struct QtWidgets_PackedString filter, struct QtWidgets_PackedString selectedFilter, long long options)
{
		return ({ QByteArray* t495363 = new QByteArray(QFileDialog::getSaveFileName(static_cast<QWidget*>(parent), QString::fromUtf8(caption.data, caption.len), QString::fromUtf8(dir.data, dir.len), QString::fromUtf8(filter.data, filter.len), new QString(QString::fromUtf8(selectedFilter.data, selectedFilter.len)), static_cast<QFileDialog::Option>(options)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t495363->prepend("WHITESPACE").constData()+10), t495363->size()-10, t495363 }; });
}

void* QFileDialog_QFileDialog_GetSaveFileUrl(void* parent, struct QtWidgets_PackedString caption, void* dir, struct QtWidgets_PackedString filter, struct QtWidgets_PackedString selectedFilter, long long options, struct QtWidgets_PackedString supportedSchemes)
{
		return new QUrl(QFileDialog::getSaveFileUrl(static_cast<QWidget*>(parent), QString::fromUtf8(caption.data, caption.len), *static_cast<QUrl*>(dir), QString::fromUtf8(filter.data, filter.len), new QString(QString::fromUtf8(selectedFilter.data, selectedFilter.len)), static_cast<QFileDialog::Option>(options), QString::fromUtf8(supportedSchemes.data, supportedSchemes.len).split("¡¦!", QString::SkipEmptyParts)));
}

struct QtWidgets_PackedString QFileDialog_History(void* ptr)
{
	return ({ QByteArray* t242067 = new QByteArray(static_cast<QFileDialog*>(ptr)->history().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t242067->prepend("WHITESPACE").constData()+10), t242067->size()-10, t242067 }; });
}

void* QFileDialog_IconProvider(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->iconProvider();
}

char QFileDialog_IsNameFilterDetailsVisible(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->isNameFilterDetailsVisible();
}

char QFileDialog_IsReadOnly(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->isReadOnly();
}

void* QFileDialog_ItemDelegate(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->itemDelegate();
}

struct QtWidgets_PackedString QFileDialog_LabelText(void* ptr, long long label)
{
	return ({ QByteArray* td750f3 = new QByteArray(static_cast<QFileDialog*>(ptr)->labelText(static_cast<QFileDialog::DialogLabel>(label)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(td750f3->prepend("WHITESPACE").constData()+10), td750f3->size()-10, td750f3 }; });
}

struct QtWidgets_PackedString QFileDialog_MimeTypeFilters(void* ptr)
{
	return ({ QByteArray* t17a2a7 = new QByteArray(static_cast<QFileDialog*>(ptr)->mimeTypeFilters().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t17a2a7->prepend("WHITESPACE").constData()+10), t17a2a7->size()-10, t17a2a7 }; });
}

struct QtWidgets_PackedString QFileDialog_NameFilters(void* ptr)
{
	return ({ QByteArray* t4389e5 = new QByteArray(static_cast<QFileDialog*>(ptr)->nameFilters().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t4389e5->prepend("WHITESPACE").constData()+10), t4389e5->size()-10, t4389e5 }; });
}

void QFileDialog_Open(void* ptr, void* receiver, char* member)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(receiver))) {
		static_cast<QFileDialog*>(ptr)->open(static_cast<QGraphicsObject*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(receiver))) {
		static_cast<QFileDialog*>(ptr)->open(static_cast<QGraphicsWidget*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(receiver))) {
		static_cast<QFileDialog*>(ptr)->open(static_cast<QLayout*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(receiver))) {
		static_cast<QFileDialog*>(ptr)->open(static_cast<QWidget*>(receiver), const_cast<const char*>(member));
	} else {
		static_cast<QFileDialog*>(ptr)->open(static_cast<QObject*>(receiver), const_cast<const char*>(member));
	}
}

long long QFileDialog_Options(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->options();
}

void* QFileDialog_ProxyModel(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->proxyModel();
}

char QFileDialog_ResolveSymlinks(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->resolveSymlinks();
}

char QFileDialog_RestoreState(void* ptr, void* state)
{
	return static_cast<QFileDialog*>(ptr)->restoreState(*static_cast<QByteArray*>(state));
}

void* QFileDialog_SaveState(void* ptr)
{
	return new QByteArray(static_cast<QFileDialog*>(ptr)->saveState());
}

void QFileDialog_SelectFile(void* ptr, struct QtWidgets_PackedString filename)
{
	static_cast<QFileDialog*>(ptr)->selectFile(QString::fromUtf8(filename.data, filename.len));
}

void QFileDialog_SelectMimeTypeFilter(void* ptr, struct QtWidgets_PackedString filter)
{
	static_cast<QFileDialog*>(ptr)->selectMimeTypeFilter(QString::fromUtf8(filter.data, filter.len));
}

void QFileDialog_SelectNameFilter(void* ptr, struct QtWidgets_PackedString filter)
{
	static_cast<QFileDialog*>(ptr)->selectNameFilter(QString::fromUtf8(filter.data, filter.len));
}

void QFileDialog_SelectUrl(void* ptr, void* url)
{
	static_cast<QFileDialog*>(ptr)->selectUrl(*static_cast<QUrl*>(url));
}

struct QtWidgets_PackedString QFileDialog_SelectedFiles(void* ptr)
{
	return ({ QByteArray* tc6127b = new QByteArray(static_cast<QFileDialog*>(ptr)->selectedFiles().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(tc6127b->prepend("WHITESPACE").constData()+10), tc6127b->size()-10, tc6127b }; });
}

struct QtWidgets_PackedString QFileDialog_SelectedMimeTypeFilter(void* ptr)
{
	return ({ QByteArray* t1558ba = new QByteArray(static_cast<QFileDialog*>(ptr)->selectedMimeTypeFilter().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t1558ba->prepend("WHITESPACE").constData()+10), t1558ba->size()-10, t1558ba }; });
}

struct QtWidgets_PackedString QFileDialog_SelectedNameFilter(void* ptr)
{
	return ({ QByteArray* tca1caa = new QByteArray(static_cast<QFileDialog*>(ptr)->selectedNameFilter().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tca1caa->prepend("WHITESPACE").constData()+10), tca1caa->size()-10, tca1caa }; });
}

struct QtWidgets_PackedList QFileDialog_SelectedUrls(void* ptr)
{
	return ({ QList<QUrl>* tmpValue9c396d = new QList<QUrl>(static_cast<QFileDialog*>(ptr)->selectedUrls()); QtWidgets_PackedList { tmpValue9c396d, tmpValue9c396d->size() }; });
}

void QFileDialog_SetAcceptMode(void* ptr, long long mode)
{
	static_cast<QFileDialog*>(ptr)->setAcceptMode(static_cast<QFileDialog::AcceptMode>(mode));
}

void QFileDialog_SetConfirmOverwrite(void* ptr, char enabled)
{
	static_cast<QFileDialog*>(ptr)->setConfirmOverwrite(enabled != 0);
}

void QFileDialog_SetDefaultSuffix(void* ptr, struct QtWidgets_PackedString suffix)
{
	static_cast<QFileDialog*>(ptr)->setDefaultSuffix(QString::fromUtf8(suffix.data, suffix.len));
}

void QFileDialog_SetDirectory(void* ptr, struct QtWidgets_PackedString directory)
{
	static_cast<QFileDialog*>(ptr)->setDirectory(QString::fromUtf8(directory.data, directory.len));
}

void QFileDialog_SetDirectory2(void* ptr, void* directory)
{
	static_cast<QFileDialog*>(ptr)->setDirectory(*static_cast<QDir*>(directory));
}

void QFileDialog_SetDirectoryUrl(void* ptr, void* directory)
{
	static_cast<QFileDialog*>(ptr)->setDirectoryUrl(*static_cast<QUrl*>(directory));
}

void QFileDialog_SetFileMode(void* ptr, long long mode)
{
	static_cast<QFileDialog*>(ptr)->setFileMode(static_cast<QFileDialog::FileMode>(mode));
}

void QFileDialog_SetFilter(void* ptr, long long filters)
{
	static_cast<QFileDialog*>(ptr)->setFilter(static_cast<QDir::Filter>(filters));
}

void QFileDialog_SetHistory(void* ptr, struct QtWidgets_PackedString paths)
{
	static_cast<QFileDialog*>(ptr)->setHistory(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts));
}

void QFileDialog_SetIconProvider(void* ptr, void* provider)
{
	static_cast<QFileDialog*>(ptr)->setIconProvider(static_cast<QFileIconProvider*>(provider));
}

void QFileDialog_SetItemDelegate(void* ptr, void* delegate)
{
	static_cast<QFileDialog*>(ptr)->setItemDelegate(static_cast<QAbstractItemDelegate*>(delegate));
}

void QFileDialog_SetLabelText(void* ptr, long long label, struct QtWidgets_PackedString text)
{
	static_cast<QFileDialog*>(ptr)->setLabelText(static_cast<QFileDialog::DialogLabel>(label), QString::fromUtf8(text.data, text.len));
}

void QFileDialog_SetMimeTypeFilters(void* ptr, struct QtWidgets_PackedString filters)
{
	static_cast<QFileDialog*>(ptr)->setMimeTypeFilters(QString::fromUtf8(filters.data, filters.len).split("¡¦!", QString::SkipEmptyParts));
}

void QFileDialog_SetNameFilter(void* ptr, struct QtWidgets_PackedString filter)
{
	static_cast<QFileDialog*>(ptr)->setNameFilter(QString::fromUtf8(filter.data, filter.len));
}

void QFileDialog_SetNameFilterDetailsVisible(void* ptr, char enabled)
{
	static_cast<QFileDialog*>(ptr)->setNameFilterDetailsVisible(enabled != 0);
}

void QFileDialog_SetNameFilters(void* ptr, struct QtWidgets_PackedString filters)
{
	static_cast<QFileDialog*>(ptr)->setNameFilters(QString::fromUtf8(filters.data, filters.len).split("¡¦!", QString::SkipEmptyParts));
}

void QFileDialog_SetOption(void* ptr, long long option, char on)
{
	static_cast<QFileDialog*>(ptr)->setOption(static_cast<QFileDialog::Option>(option), on != 0);
}

void QFileDialog_SetOptions(void* ptr, long long options)
{
	static_cast<QFileDialog*>(ptr)->setOptions(static_cast<QFileDialog::Option>(options));
}

void QFileDialog_SetProxyModel(void* ptr, void* proxyModel)
{
	static_cast<QFileDialog*>(ptr)->setProxyModel(static_cast<QAbstractProxyModel*>(proxyModel));
}

void QFileDialog_SetReadOnly(void* ptr, char enabled)
{
	static_cast<QFileDialog*>(ptr)->setReadOnly(enabled != 0);
}

void QFileDialog_SetResolveSymlinks(void* ptr, char enabled)
{
	static_cast<QFileDialog*>(ptr)->setResolveSymlinks(enabled != 0);
}

void QFileDialog_SetSidebarUrls(void* ptr, void* urls)
{
	static_cast<QFileDialog*>(ptr)->setSidebarUrls(*static_cast<QList<QUrl>*>(urls));
}

void QFileDialog_SetSupportedSchemes(void* ptr, struct QtWidgets_PackedString schemes)
{
	static_cast<QFileDialog*>(ptr)->setSupportedSchemes(QString::fromUtf8(schemes.data, schemes.len).split("¡¦!", QString::SkipEmptyParts));
}

void QFileDialog_SetViewMode(void* ptr, long long mode)
{
	static_cast<QFileDialog*>(ptr)->setViewMode(static_cast<QFileDialog::ViewMode>(mode));
}

struct QtWidgets_PackedList QFileDialog_SidebarUrls(void* ptr)
{
	return ({ QList<QUrl>* tmpValue8706b9 = new QList<QUrl>(static_cast<QFileDialog*>(ptr)->sidebarUrls()); QtWidgets_PackedList { tmpValue8706b9, tmpValue8706b9->size() }; });
}

struct QtWidgets_PackedString QFileDialog_SupportedSchemes(void* ptr)
{
	return ({ QByteArray* tfcd263 = new QByteArray(static_cast<QFileDialog*>(ptr)->supportedSchemes().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(tfcd263->prepend("WHITESPACE").constData()+10), tfcd263->size()-10, tfcd263 }; });
}

char QFileDialog_TestOption(void* ptr, long long option)
{
	return static_cast<QFileDialog*>(ptr)->testOption(static_cast<QFileDialog::Option>(option));
}

void QFileDialog_ConnectUrlSelected(void* ptr, long long t)
{
	QObject::connect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QUrl &)>(&QFileDialog::urlSelected), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QUrl &)>(&MyQFileDialog::Signal_UrlSelected), static_cast<Qt::ConnectionType>(t));
}

void QFileDialog_DisconnectUrlSelected(void* ptr)
{
	QObject::disconnect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QUrl &)>(&QFileDialog::urlSelected), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QUrl &)>(&MyQFileDialog::Signal_UrlSelected));
}

void QFileDialog_UrlSelected(void* ptr, void* url)
{
	static_cast<QFileDialog*>(ptr)->urlSelected(*static_cast<QUrl*>(url));
}

void QFileDialog_ConnectUrlsSelected(void* ptr, long long t)
{
	QObject::connect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QList<QUrl> &)>(&QFileDialog::urlsSelected), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QList<QUrl> &)>(&MyQFileDialog::Signal_UrlsSelected), static_cast<Qt::ConnectionType>(t));
}

void QFileDialog_DisconnectUrlsSelected(void* ptr)
{
	QObject::disconnect(static_cast<QFileDialog*>(ptr), static_cast<void (QFileDialog::*)(const QList<QUrl> &)>(&QFileDialog::urlsSelected), static_cast<MyQFileDialog*>(ptr), static_cast<void (MyQFileDialog::*)(const QList<QUrl> &)>(&MyQFileDialog::Signal_UrlsSelected));
}

void QFileDialog_UrlsSelected(void* ptr, void* urls)
{
	static_cast<QFileDialog*>(ptr)->urlsSelected(*static_cast<QList<QUrl>*>(urls));
}

long long QFileDialog_ViewMode(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->viewMode();
}

void QFileDialog_DestroyQFileDialog(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->~QFileDialog();
}

void QFileDialog_DestroyQFileDialogDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QFileDialog___getOpenFileUrls_atList(void* ptr, int i)
{
	return new QUrl(({QUrl tmp = static_cast<QList<QUrl>*>(ptr)->at(i); if (i == static_cast<QList<QUrl>*>(ptr)->size()-1) { static_cast<QList<QUrl>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QFileDialog___getOpenFileUrls_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QUrl>();
}

void* QFileDialog___selectedUrls_atList(void* ptr, int i)
{
	return new QUrl(({QUrl tmp = static_cast<QList<QUrl>*>(ptr)->at(i); if (i == static_cast<QList<QUrl>*>(ptr)->size()-1) { static_cast<QList<QUrl>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QFileDialog___selectedUrls_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QUrl>();
}

void* QFileDialog___setSidebarUrls_urls_atList(void* ptr, int i)
{
	return new QUrl(({QUrl tmp = static_cast<QList<QUrl>*>(ptr)->at(i); if (i == static_cast<QList<QUrl>*>(ptr)->size()-1) { static_cast<QList<QUrl>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QFileDialog___setSidebarUrls_urls_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QUrl>();
}

void* QFileDialog___sidebarUrls_atList(void* ptr, int i)
{
	return new QUrl(({QUrl tmp = static_cast<QList<QUrl>*>(ptr)->at(i); if (i == static_cast<QList<QUrl>*>(ptr)->size()-1) { static_cast<QList<QUrl>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QFileDialog___sidebarUrls_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QUrl>();
}

void* QFileDialog___urlsSelected_urls_atList(void* ptr, int i)
{
	return new QUrl(({QUrl tmp = static_cast<QList<QUrl>*>(ptr)->at(i); if (i == static_cast<QList<QUrl>*>(ptr)->size()-1) { static_cast<QList<QUrl>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QFileDialog___urlsSelected_urls_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QUrl>();
}

class MyQFileIconProvider: public QFileIconProvider
{
public:
	MyQFileIconProvider() : QFileIconProvider() {QFileIconProvider_QFileIconProvider_QRegisterMetaType();};
	QIcon icon(QFileIconProvider::IconType ty) const { return *static_cast<QIcon*>(callbackQFileIconProvider_Icon(const_cast<void*>(static_cast<const void*>(this)), ty)); };
	QIcon icon(const QFileInfo & info) const { return *static_cast<QIcon*>(callbackQFileIconProvider_Icon2(const_cast<void*>(static_cast<const void*>(this)), const_cast<QFileInfo*>(&info))); };
	QString type(const QFileInfo & info) const { return ({ QtWidgets_PackedString tempVal = callbackQFileIconProvider_Type(const_cast<void*>(static_cast<const void*>(this)), const_cast<QFileInfo*>(&info)); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	 ~MyQFileIconProvider() { callbackQFileIconProvider_DestroyQFileIconProvider(this); };
};

Q_DECLARE_METATYPE(QFileIconProvider*)
Q_DECLARE_METATYPE(MyQFileIconProvider*)

int QFileIconProvider_QFileIconProvider_QRegisterMetaType(){qRegisterMetaType<QFileIconProvider*>(); return qRegisterMetaType<MyQFileIconProvider*>();}

void* QFileIconProvider_NewQFileIconProvider()
{
	return new MyQFileIconProvider();
}

void* QFileIconProvider_Icon(void* ptr, long long ty)
{
	return new QIcon(static_cast<QFileIconProvider*>(ptr)->icon(static_cast<QFileIconProvider::IconType>(ty)));
}

void* QFileIconProvider_IconDefault(void* ptr, long long ty)
{
		return new QIcon(static_cast<QFileIconProvider*>(ptr)->QFileIconProvider::icon(static_cast<QFileIconProvider::IconType>(ty)));
}

void* QFileIconProvider_Icon2(void* ptr, void* info)
{
	return new QIcon(static_cast<QFileIconProvider*>(ptr)->icon(*static_cast<QFileInfo*>(info)));
}

void* QFileIconProvider_Icon2Default(void* ptr, void* info)
{
		return new QIcon(static_cast<QFileIconProvider*>(ptr)->QFileIconProvider::icon(*static_cast<QFileInfo*>(info)));
}

long long QFileIconProvider_Options(void* ptr)
{
	return static_cast<QFileIconProvider*>(ptr)->options();
}

void QFileIconProvider_SetOptions(void* ptr, long long options)
{
	static_cast<QFileIconProvider*>(ptr)->setOptions(static_cast<QFileIconProvider::Option>(options));
}

struct QtWidgets_PackedString QFileIconProvider_Type(void* ptr, void* info)
{
	return ({ QByteArray* t69d0f8 = new QByteArray(static_cast<QFileIconProvider*>(ptr)->type(*static_cast<QFileInfo*>(info)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t69d0f8->prepend("WHITESPACE").constData()+10), t69d0f8->size()-10, t69d0f8 }; });
}

struct QtWidgets_PackedString QFileIconProvider_TypeDefault(void* ptr, void* info)
{
		return ({ QByteArray* tb3bd2f = new QByteArray(static_cast<QFileIconProvider*>(ptr)->QFileIconProvider::type(*static_cast<QFileInfo*>(info)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tb3bd2f->prepend("WHITESPACE").constData()+10), tb3bd2f->size()-10, tb3bd2f }; });
}

void QFileIconProvider_DestroyQFileIconProvider(void* ptr)
{
	static_cast<QFileIconProvider*>(ptr)->~QFileIconProvider();
}

void QFileIconProvider_DestroyQFileIconProviderDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQFileSystemModel: public QFileSystemModel
{
public:
	MyQFileSystemModel(QObject *parent = Q_NULLPTR) : QFileSystemModel(parent) {QFileSystemModel_QFileSystemModel_QRegisterMetaType();};
	bool canFetchMore(const QModelIndex & parent) const { return callbackQFileSystemModel_CanFetchMore(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
	int columnCount(const QModelIndex & parent) const { return callbackQFileSystemModel_ColumnCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
	QVariant data(const QModelIndex & index, int role) const { return *static_cast<QVariant*>(callbackQFileSystemModel_Data(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), role)); };
	void Signal_DirectoryLoaded(const QString & path) { QByteArray* t3150ec = new QByteArray(path.toUtf8()); QtWidgets_PackedString pathPacked = { const_cast<char*>(t3150ec->prepend("WHITESPACE").constData()+10), t3150ec->size()-10, t3150ec };callbackQFileSystemModel_DirectoryLoaded(this, pathPacked); };
	bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQFileSystemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
	bool event(QEvent * event) { return callbackQFileSystemModel_Event(this, event) != 0; };
	void fetchMore(const QModelIndex & parent) { callbackQFileSystemModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
	void Signal_FileRenamed(const QString & path, const QString & oldName, const QString & newName) { QByteArray* t3150ec = new QByteArray(path.toUtf8()); QtWidgets_PackedString pathPacked = { const_cast<char*>(t3150ec->prepend("WHITESPACE").constData()+10), t3150ec->size()-10, t3150ec };QByteArray* td041bb = new QByteArray(oldName.toUtf8()); QtWidgets_PackedString oldNamePacked = { const_cast<char*>(td041bb->prepend("WHITESPACE").constData()+10), td041bb->size()-10, td041bb };QByteArray* t1530cb = new QByteArray(newName.toUtf8()); QtWidgets_PackedString newNamePacked = { const_cast<char*>(t1530cb->prepend("WHITESPACE").constData()+10), t1530cb->size()-10, t1530cb };callbackQFileSystemModel_FileRenamed(this, pathPacked, oldNamePacked, newNamePacked); };
	Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQFileSystemModel_Flags(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	bool hasChildren(const QModelIndex & parent) const { return callbackQFileSystemModel_HasChildren(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
	QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQFileSystemModel_HeaderData(const_cast<void*>(static_cast<const void*>(this)), section, orientation, role)); };
	QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQFileSystemModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
	QMimeData * mimeData(const QModelIndexList & indexes) const { return static_cast<QMimeData*>(callbackQFileSystemModel_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QModelIndex>* tmpValuee0adf2 = new QList<QModelIndex>(indexes); QtWidgets_PackedList { tmpValuee0adf2, tmpValuee0adf2->size() }; }))); };
	QStringList mimeTypes() const { return ({ QtWidgets_PackedString tempVal = callbackQFileSystemModel_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	QModelIndex parent(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQFileSystemModel_Parent(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	void Signal_RootPathChanged(const QString & newPath) { QByteArray* t1ced92 = new QByteArray(newPath.toUtf8()); QtWidgets_PackedString newPathPacked = { const_cast<char*>(t1ced92->prepend("WHITESPACE").constData()+10), t1ced92->size()-10, t1ced92 };callbackQFileSystemModel_RootPathChanged(this, newPathPacked); };
	int rowCount(const QModelIndex & parent) const { return callbackQFileSystemModel_RowCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
	bool setData(const QModelIndex & idx, const QVariant & value, int role) { return callbackQFileSystemModel_SetData(this, const_cast<QModelIndex*>(&idx), const_cast<QVariant*>(&value), role) != 0; };
	QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQFileSystemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&idx))); };
	void sort(int column, Qt::SortOrder order) { callbackQFileSystemModel_Sort(this, column, order); };
	Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQFileSystemModel_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
	void timerEvent(QTimerEvent * event) { callbackQFileSystemModel_TimerEvent(this, event); };
	 ~MyQFileSystemModel() { callbackQFileSystemModel_DestroyQFileSystemModel(this); };
	QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQFileSystemModel_Buddy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQFileSystemModel_CanDropMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
	void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last) { callbackQFileSystemModel_ColumnsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn) { callbackQFileSystemModel_ColumnsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationColumn); };
	void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQFileSystemModel_ColumnsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last) { callbackQFileSystemModel_ColumnsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column) { callbackQFileSystemModel_ColumnsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), column); };
	void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last) { callbackQFileSystemModel_ColumnsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_DataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQFileSystemModel_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
	void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last) { callbackQFileSystemModel_HeaderDataChanged(this, orientation, first, last); };
	bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQFileSystemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
	bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQFileSystemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
	QMap<int, QVariant> itemData(const QModelIndex & index) const { return ({ QMap<int, QVariant>* tmpP = static_cast<QMap<int, QVariant>*>(callbackQFileSystemModel_ItemData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); QMap<int, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }); };
	void Signal_LayoutAboutToBeChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQFileSystemModel_LayoutAboutToBeChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtWidgets_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
	void Signal_LayoutChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQFileSystemModel_LayoutChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtWidgets_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
	QList<QModelIndex> match(const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags) const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQFileSystemModel_Match(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&start), role, const_cast<QVariant*>(&value), hits, flags)); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void Signal_ModelAboutToBeReset() { callbackQFileSystemModel_ModelAboutToBeReset(this); };
	void Signal_ModelReset() { callbackQFileSystemModel_ModelReset(this); };
	bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQFileSystemModel_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 callbackQFileSystemModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
	bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQFileSystemModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
	bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQFileSystemModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
	void resetInternalData() { callbackQFileSystemModel_ResetInternalData(this); };
	void revert() { callbackQFileSystemModel_Revert(this); };
	QHash<int, QByteArray> roleNames() const { return ({ QHash<int, QByteArray>* tmpP = static_cast<QHash<int, QByteArray>*>(callbackQFileSystemModel_RoleNames(const_cast<void*>(static_cast<const void*>(this)))); QHash<int, QByteArray> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; }); };
	void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end) { callbackQFileSystemModel_RowsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow) { callbackQFileSystemModel_RowsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationRow); };
	void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQFileSystemModel_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_RowsInserted(const QModelIndex & parent, int first, int last) { callbackQFileSystemModel_RowsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row) { callbackQFileSystemModel_RowsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), row); };
	void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQFileSystemModel_RowsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
	bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQFileSystemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
	bool setItemData(const QModelIndex & index, const QMap<int, QVariant> & roles) { return callbackQFileSystemModel_SetItemData(this, const_cast<QModelIndex*>(&index), ({ QMap<int, QVariant>* tmpValue037c88 = new QMap<int, QVariant>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })) != 0; };
	QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQFileSystemModel_Span(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	bool submit() { return callbackQFileSystemModel_Submit(this) != 0; };
	Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQFileSystemModel_SupportedDragActions(const_cast<void*>(static_cast<const void*>(this)))); };
	void childEvent(QChildEvent * event) { callbackQFileSystemModel_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQFileSystemModel_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQFileSystemModel_CustomEvent(this, event); };
	void deleteLater() { callbackQFileSystemModel_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQFileSystemModel_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQFileSystemModel_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQFileSystemModel_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFileSystemModel_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQFileSystemModel_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QFileSystemModel*)
Q_DECLARE_METATYPE(MyQFileSystemModel*)

int QFileSystemModel_QFileSystemModel_QRegisterMetaType(){qRegisterMetaType<QFileSystemModel*>(); return qRegisterMetaType<MyQFileSystemModel*>();}

int QFileSystemModel_FilePathRole_Type()
{
	return QFileSystemModel::FilePathRole;
}

int QFileSystemModel_FileNameRole_Type()
{
	return QFileSystemModel::FileNameRole;
}

int QFileSystemModel_FilePermissions_Type()
{
	return QFileSystemModel::FilePermissions;
}

void* QFileSystemModel_NewQFileSystemModel(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQFileSystemModel(static_cast<QWindow*>(parent));
	} else {
		return new MyQFileSystemModel(static_cast<QObject*>(parent));
	}
}

char QFileSystemModel_CanFetchMoreDefault(void* ptr, void* parent)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::canFetchMore(*static_cast<QModelIndex*>(parent));
}

int QFileSystemModel_ColumnCount(void* ptr, void* parent)
{
	return static_cast<QFileSystemModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}

int QFileSystemModel_ColumnCountDefault(void* ptr, void* parent)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::columnCount(*static_cast<QModelIndex*>(parent));
}

void* QFileSystemModel_Data(void* ptr, void* index, int role)
{
	return new QVariant(static_cast<QFileSystemModel*>(ptr)->data(*static_cast<QModelIndex*>(index), role));
}

void* QFileSystemModel_DataDefault(void* ptr, void* index, int role)
{
		return new QVariant(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::data(*static_cast<QModelIndex*>(index), role));
}

void QFileSystemModel_ConnectDirectoryLoaded(void* ptr, long long t)
{
	QObject::connect(static_cast<QFileSystemModel*>(ptr), static_cast<void (QFileSystemModel::*)(const QString &)>(&QFileSystemModel::directoryLoaded), static_cast<MyQFileSystemModel*>(ptr), static_cast<void (MyQFileSystemModel::*)(const QString &)>(&MyQFileSystemModel::Signal_DirectoryLoaded), static_cast<Qt::ConnectionType>(t));
}

void QFileSystemModel_DisconnectDirectoryLoaded(void* ptr)
{
	QObject::disconnect(static_cast<QFileSystemModel*>(ptr), static_cast<void (QFileSystemModel::*)(const QString &)>(&QFileSystemModel::directoryLoaded), static_cast<MyQFileSystemModel*>(ptr), static_cast<void (MyQFileSystemModel::*)(const QString &)>(&MyQFileSystemModel::Signal_DirectoryLoaded));
}

void QFileSystemModel_DirectoryLoaded(void* ptr, struct QtWidgets_PackedString path)
{
	static_cast<QFileSystemModel*>(ptr)->directoryLoaded(QString::fromUtf8(path.data, path.len));
}

char QFileSystemModel_DropMimeDataDefault(void* ptr, void* data, long long action, int row, int column, void* parent)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}

char QFileSystemModel_EventDefault(void* ptr, void* event)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::event(static_cast<QEvent*>(event));
}

void QFileSystemModel_FetchMoreDefault(void* ptr, void* parent)
{
		static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::fetchMore(*static_cast<QModelIndex*>(parent));
}

void* QFileSystemModel_FileIcon(void* ptr, void* index)
{
	return new QIcon(static_cast<QFileSystemModel*>(ptr)->fileIcon(*static_cast<QModelIndex*>(index)));
}

void* QFileSystemModel_FileInfo(void* ptr, void* index)
{
	return new QFileInfo(static_cast<QFileSystemModel*>(ptr)->fileInfo(*static_cast<QModelIndex*>(index)));
}

struct QtWidgets_PackedString QFileSystemModel_FileName(void* ptr, void* index)
{
	return ({ QByteArray* t9528ac = new QByteArray(static_cast<QFileSystemModel*>(ptr)->fileName(*static_cast<QModelIndex*>(index)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t9528ac->prepend("WHITESPACE").constData()+10), t9528ac->size()-10, t9528ac }; });
}

struct QtWidgets_PackedString QFileSystemModel_FilePath(void* ptr, void* index)
{
	return ({ QByteArray* t6d0e31 = new QByteArray(static_cast<QFileSystemModel*>(ptr)->filePath(*static_cast<QModelIndex*>(index)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t6d0e31->prepend("WHITESPACE").constData()+10), t6d0e31->size()-10, t6d0e31 }; });
}

void QFileSystemModel_ConnectFileRenamed(void* ptr, long long t)
{
	QObject::connect(static_cast<QFileSystemModel*>(ptr), static_cast<void (QFileSystemModel::*)(const QString &, const QString &, const QString &)>(&QFileSystemModel::fileRenamed), static_cast<MyQFileSystemModel*>(ptr), static_cast<void (MyQFileSystemModel::*)(const QString &, const QString &, const QString &)>(&MyQFileSystemModel::Signal_FileRenamed), static_cast<Qt::ConnectionType>(t));
}

void QFileSystemModel_DisconnectFileRenamed(void* ptr)
{
	QObject::disconnect(static_cast<QFileSystemModel*>(ptr), static_cast<void (QFileSystemModel::*)(const QString &, const QString &, const QString &)>(&QFileSystemModel::fileRenamed), static_cast<MyQFileSystemModel*>(ptr), static_cast<void (MyQFileSystemModel::*)(const QString &, const QString &, const QString &)>(&MyQFileSystemModel::Signal_FileRenamed));
}

void QFileSystemModel_FileRenamed(void* ptr, struct QtWidgets_PackedString path, struct QtWidgets_PackedString oldName, struct QtWidgets_PackedString newName)
{
	static_cast<QFileSystemModel*>(ptr)->fileRenamed(QString::fromUtf8(path.data, path.len), QString::fromUtf8(oldName.data, oldName.len), QString::fromUtf8(newName.data, newName.len));
}

long long QFileSystemModel_Filter(void* ptr)
{
	return static_cast<QFileSystemModel*>(ptr)->filter();
}

long long QFileSystemModel_FlagsDefault(void* ptr, void* index)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::flags(*static_cast<QModelIndex*>(index));
}

char QFileSystemModel_HasChildrenDefault(void* ptr, void* parent)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::hasChildren(*static_cast<QModelIndex*>(parent));
}

void* QFileSystemModel_HeaderDataDefault(void* ptr, int section, long long orientation, int role)
{
		return new QVariant(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
}

void* QFileSystemModel_IconProvider(void* ptr)
{
	return static_cast<QFileSystemModel*>(ptr)->iconProvider();
}

void* QFileSystemModel_Index(void* ptr, int row, int column, void* parent)
{
	return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)));
}

void* QFileSystemModel_IndexDefault(void* ptr, int row, int column, void* parent)
{
		return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::index(row, column, *static_cast<QModelIndex*>(parent)));
}

void* QFileSystemModel_Index2(void* ptr, struct QtWidgets_PackedString path, int column)
{
	return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->index(QString::fromUtf8(path.data, path.len), column));
}

char QFileSystemModel_IsDir(void* ptr, void* index)
{
	return static_cast<QFileSystemModel*>(ptr)->isDir(*static_cast<QModelIndex*>(index));
}

char QFileSystemModel_IsReadOnly(void* ptr)
{
	return static_cast<QFileSystemModel*>(ptr)->isReadOnly();
}

void* QFileSystemModel_LastModified(void* ptr, void* index)
{
	return new QDateTime(static_cast<QFileSystemModel*>(ptr)->lastModified(*static_cast<QModelIndex*>(index)));
}

void* QFileSystemModel_MimeDataDefault(void* ptr, void* indexes)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::mimeData(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(indexes); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
}

struct QtWidgets_PackedString QFileSystemModel_MimeTypesDefault(void* ptr)
{
		return ({ QByteArray* t836878 = new QByteArray(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::mimeTypes().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t836878->prepend("WHITESPACE").constData()+10), t836878->size()-10, t836878 }; });
}

void* QFileSystemModel_Mkdir(void* ptr, void* parent, struct QtWidgets_PackedString name)
{
	return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->mkdir(*static_cast<QModelIndex*>(parent), QString::fromUtf8(name.data, name.len)));
}

void* QFileSystemModel_MyComputer(void* ptr, int role)
{
	return new QVariant(static_cast<QFileSystemModel*>(ptr)->myComputer(role));
}

char QFileSystemModel_NameFilterDisables(void* ptr)
{
	return static_cast<QFileSystemModel*>(ptr)->nameFilterDisables();
}

struct QtWidgets_PackedString QFileSystemModel_NameFilters(void* ptr)
{
	return ({ QByteArray* te17825 = new QByteArray(static_cast<QFileSystemModel*>(ptr)->nameFilters().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(te17825->prepend("WHITESPACE").constData()+10), te17825->size()-10, te17825 }; });
}

void* QFileSystemModel_Parent(void* ptr, void* index)
{
	return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->parent(*static_cast<QModelIndex*>(index)));
}

void* QFileSystemModel_ParentDefault(void* ptr, void* index)
{
		return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::parent(*static_cast<QModelIndex*>(index)));
}

char QFileSystemModel_Remove(void* ptr, void* index)
{
	return static_cast<QFileSystemModel*>(ptr)->remove(*static_cast<QModelIndex*>(index));
}

char QFileSystemModel_ResolveSymlinks(void* ptr)
{
	return static_cast<QFileSystemModel*>(ptr)->resolveSymlinks();
}

char QFileSystemModel_Rmdir(void* ptr, void* index)
{
	return static_cast<QFileSystemModel*>(ptr)->rmdir(*static_cast<QModelIndex*>(index));
}

void* QFileSystemModel_RootDirectory(void* ptr)
{
	return new QDir(static_cast<QFileSystemModel*>(ptr)->rootDirectory());
}

struct QtWidgets_PackedString QFileSystemModel_RootPath(void* ptr)
{
	return ({ QByteArray* tdcb5b3 = new QByteArray(static_cast<QFileSystemModel*>(ptr)->rootPath().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tdcb5b3->prepend("WHITESPACE").constData()+10), tdcb5b3->size()-10, tdcb5b3 }; });
}

void QFileSystemModel_ConnectRootPathChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QFileSystemModel*>(ptr), static_cast<void (QFileSystemModel::*)(const QString &)>(&QFileSystemModel::rootPathChanged), static_cast<MyQFileSystemModel*>(ptr), static_cast<void (MyQFileSystemModel::*)(const QString &)>(&MyQFileSystemModel::Signal_RootPathChanged), static_cast<Qt::ConnectionType>(t));
}

void QFileSystemModel_DisconnectRootPathChanged(void* ptr)
{
	QObject::disconnect(static_cast<QFileSystemModel*>(ptr), static_cast<void (QFileSystemModel::*)(const QString &)>(&QFileSystemModel::rootPathChanged), static_cast<MyQFileSystemModel*>(ptr), static_cast<void (MyQFileSystemModel::*)(const QString &)>(&MyQFileSystemModel::Signal_RootPathChanged));
}

void QFileSystemModel_RootPathChanged(void* ptr, struct QtWidgets_PackedString newPath)
{
	static_cast<QFileSystemModel*>(ptr)->rootPathChanged(QString::fromUtf8(newPath.data, newPath.len));
}

int QFileSystemModel_RowCount(void* ptr, void* parent)
{
	return static_cast<QFileSystemModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}

int QFileSystemModel_RowCountDefault(void* ptr, void* parent)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::rowCount(*static_cast<QModelIndex*>(parent));
}

char QFileSystemModel_SetDataDefault(void* ptr, void* idx, void* value, int role)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::setData(*static_cast<QModelIndex*>(idx), *static_cast<QVariant*>(value), role);
}

void QFileSystemModel_SetFilter(void* ptr, long long filters)
{
	static_cast<QFileSystemModel*>(ptr)->setFilter(static_cast<QDir::Filter>(filters));
}

void QFileSystemModel_SetIconProvider(void* ptr, void* provider)
{
	static_cast<QFileSystemModel*>(ptr)->setIconProvider(static_cast<QFileIconProvider*>(provider));
}

void QFileSystemModel_SetNameFilterDisables(void* ptr, char enable)
{
	static_cast<QFileSystemModel*>(ptr)->setNameFilterDisables(enable != 0);
}

void QFileSystemModel_SetNameFilters(void* ptr, struct QtWidgets_PackedString filters)
{
	static_cast<QFileSystemModel*>(ptr)->setNameFilters(QString::fromUtf8(filters.data, filters.len).split("¡¦!", QString::SkipEmptyParts));
}

void QFileSystemModel_SetReadOnly(void* ptr, char enable)
{
	static_cast<QFileSystemModel*>(ptr)->setReadOnly(enable != 0);
}

void QFileSystemModel_SetResolveSymlinks(void* ptr, char enable)
{
	static_cast<QFileSystemModel*>(ptr)->setResolveSymlinks(enable != 0);
}

void* QFileSystemModel_SetRootPath(void* ptr, struct QtWidgets_PackedString newPath)
{
	return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->setRootPath(QString::fromUtf8(newPath.data, newPath.len)));
}

void* QFileSystemModel_SiblingDefault(void* ptr, int row, int column, void* idx)
{
		return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::sibling(row, column, *static_cast<QModelIndex*>(idx)));
}

long long QFileSystemModel_Size(void* ptr, void* index)
{
	return static_cast<QFileSystemModel*>(ptr)->size(*static_cast<QModelIndex*>(index));
}

void QFileSystemModel_SortDefault(void* ptr, int column, long long order)
{
		static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::sort(column, static_cast<Qt::SortOrder>(order));
}

long long QFileSystemModel_SupportedDropActionsDefault(void* ptr)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::supportedDropActions();
}

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

struct QtWidgets_PackedString QFileSystemModel_Type(void* ptr, void* index)
{
	return ({ QByteArray* tf8baa8 = new QByteArray(static_cast<QFileSystemModel*>(ptr)->type(*static_cast<QModelIndex*>(index)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tf8baa8->prepend("WHITESPACE").constData()+10), tf8baa8->size()-10, tf8baa8 }; });
}

void QFileSystemModel_DestroyQFileSystemModel(void* ptr)
{
	static_cast<QFileSystemModel*>(ptr)->~QFileSystemModel();
}

void QFileSystemModel_DestroyQFileSystemModelDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QFileSystemModel___mimeData_indexes_atList(void* ptr, int i)
{
	return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QFileSystemModel___mimeData_indexes_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QModelIndex>();
}

void* QFileSystemModel___changePersistentIndexList_from_atList(void* ptr, int i)
{
	return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QFileSystemModel___changePersistentIndexList_from_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QModelIndex>();
}

void* QFileSystemModel___changePersistentIndexList_to_atList(void* ptr, int i)
{
	return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QFileSystemModel___changePersistentIndexList_to_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QModelIndex>();
}

int QFileSystemModel___dataChanged_roles_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QVector<int>*>(ptr)->at(i); if (i == static_cast<QVector<int>*>(ptr)->size()-1) { static_cast<QVector<int>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}

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

void* QFileSystemModel___dataChanged_roles_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<int>();
}

void* QFileSystemModel___itemData_atList(void* ptr, int v, int i)
{
	return new QVariant(({ QVariant tmp = static_cast<QMap<int, QVariant>*>(ptr)->value(v); if (i == static_cast<QMap<int, QVariant>*>(ptr)->size()-1) { static_cast<QMap<int, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QFileSystemModel___itemData_setList(void* ptr, int key, void* i)
{
	static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}

void* QFileSystemModel___itemData_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<int, QVariant>();
}

struct QtWidgets_PackedList QFileSystemModel___itemData_keyList(void* ptr)
{
	return ({ QList<int>* tmpValue249128 = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtWidgets_PackedList { tmpValue249128, tmpValue249128->size() }; });
}

void* QFileSystemModel___layoutAboutToBeChanged_parents_atList(void* ptr, int i)
{
	return new QPersistentModelIndex(({QPersistentModelIndex tmp = static_cast<QList<QPersistentModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QPersistentModelIndex>*>(ptr)->size()-1) { static_cast<QList<QPersistentModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QFileSystemModel___layoutAboutToBeChanged_parents_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QPersistentModelIndex>();
}

void* QFileSystemModel___layoutChanged_parents_atList(void* ptr, int i)
{
	return new QPersistentModelIndex(({QPersistentModelIndex tmp = static_cast<QList<QPersistentModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QPersistentModelIndex>*>(ptr)->size()-1) { static_cast<QList<QPersistentModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QFileSystemModel___layoutChanged_parents_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QPersistentModelIndex>();
}

void* QFileSystemModel___match_atList(void* ptr, int i)
{
	return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QFileSystemModel___match_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QModelIndex>();
}

void* QFileSystemModel___persistentIndexList_atList(void* ptr, int i)
{
	return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QFileSystemModel___persistentIndexList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QModelIndex>();
}

void* QFileSystemModel___roleNames_atList(void* ptr, int v, int i)
{
	return new QByteArray(({ QByteArray tmp = static_cast<QHash<int, QByteArray>*>(ptr)->value(v); if (i == static_cast<QHash<int, QByteArray>*>(ptr)->size()-1) { static_cast<QHash<int, QByteArray>*>(ptr)->~QHash(); free(ptr); }; tmp; }));
}

void QFileSystemModel___roleNames_setList(void* ptr, int key, void* i)
{
	static_cast<QHash<int, QByteArray>*>(ptr)->insert(key, *static_cast<QByteArray*>(i));
}

void* QFileSystemModel___roleNames_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QHash<int, QByteArray>();
}

struct QtWidgets_PackedList QFileSystemModel___roleNames_keyList(void* ptr)
{
	return ({ QList<int>* tmpValue7fc3bb = new QList<int>(static_cast<QHash<int, QByteArray>*>(ptr)->keys()); QtWidgets_PackedList { tmpValue7fc3bb, tmpValue7fc3bb->size() }; });
}

void* QFileSystemModel___setItemData_roles_atList(void* ptr, int v, int i)
{
	return new QVariant(({ QVariant tmp = static_cast<QMap<int, QVariant>*>(ptr)->value(v); if (i == static_cast<QMap<int, QVariant>*>(ptr)->size()-1) { static_cast<QMap<int, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}

void QFileSystemModel___setItemData_roles_setList(void* ptr, int key, void* i)
{
	static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}

void* QFileSystemModel___setItemData_roles_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<int, QVariant>();
}

struct QtWidgets_PackedList QFileSystemModel___setItemData_roles_keyList(void* ptr)
{
	return ({ QList<int>* tmpValue249128 = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtWidgets_PackedList { tmpValue249128, tmpValue249128->size() }; });
}

int QFileSystemModel_____doSetRoleNames_roleNames_keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

int QFileSystemModel_____itemData_keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

int QFileSystemModel_____roleNames_keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

int QFileSystemModel_____setItemData_roles_keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

int QFileSystemModel_____setRoleNames_roleNames_keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

void* QFileSystemModel___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QFileSystemModel___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QFileSystemModel___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QFileSystemModel___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QFileSystemModel___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QFileSystemModel___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QFileSystemModel___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QFileSystemModel_BuddyDefault(void* ptr, void* index)
{
		return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::buddy(*static_cast<QModelIndex*>(index)));
}

char QFileSystemModel_CanDropMimeDataDefault(void* ptr, void* data, long long action, int row, int column, void* parent)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}

char QFileSystemModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
}

char QFileSystemModel_InsertRowsDefault(void* ptr, int row, int count, void* parent)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
}

struct QtWidgets_PackedList QFileSystemModel_ItemDataDefault(void* ptr, void* index)
{
		return ({ QMap<int, QVariant>* tmpValued0d48b = new QMap<int, QVariant>(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::itemData(*static_cast<QModelIndex*>(index))); QtWidgets_PackedList { tmpValued0d48b, tmpValued0d48b->size() }; });
}

struct QtWidgets_PackedList QFileSystemModel_MatchDefault(void* ptr, void* start, int role, void* value, int hits, long long flags)
{
		return ({ QList<QModelIndex>* tmpValue7e8d26 = new QList<QModelIndex>(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtWidgets_PackedList { tmpValue7e8d26, tmpValue7e8d26->size() }; });
}

char QFileSystemModel_MoveColumnsDefault(void* ptr, void* sourceParent, int sourceColumn, int count, void* destinationParent, int destinationChild)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}

char QFileSystemModel_MoveRowsDefault(void* ptr, void* sourceParent, int sourceRow, int count, void* destinationParent, int destinationChild)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}

char QFileSystemModel_RemoveColumnsDefault(void* ptr, int column, int count, void* parent)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
}

char QFileSystemModel_RemoveRowsDefault(void* ptr, int row, int count, void* parent)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
}

void QFileSystemModel_ResetInternalDataDefault(void* ptr)
{
		static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::resetInternalData();
}

void QFileSystemModel_RevertDefault(void* ptr)
{
		static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::revert();
}

struct QtWidgets_PackedList QFileSystemModel_RoleNamesDefault(void* ptr)
{
		return ({ QHash<int, QByteArray>* tmpValue50afa5 = new QHash<int, QByteArray>(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::roleNames()); QtWidgets_PackedList { tmpValue50afa5, tmpValue50afa5->size() }; });
}

char QFileSystemModel_SetHeaderDataDefault(void* ptr, int section, long long orientation, void* value, int role)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
}

char QFileSystemModel_SetItemDataDefault(void* ptr, void* index, void* roles)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
}

void* QFileSystemModel_SpanDefault(void* ptr, void* index)
{
		return ({ QSize tmpValue = static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
}

char QFileSystemModel_SubmitDefault(void* ptr)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::submit();
}

long long QFileSystemModel_SupportedDragActionsDefault(void* ptr)
{
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::supportedDragActions();
}

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

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

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

void QFileSystemModel_DeleteLaterDefault(void* ptr)
{
		static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::deleteLater();
}

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

char QFileSystemModel_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

class MyQFocusFrame: public QFocusFrame
{
public:
	MyQFocusFrame(QWidget *parent = Q_NULLPTR) : QFocusFrame(parent) {QFocusFrame_QFocusFrame_QRegisterMetaType();};
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	bool eventFilter(QObject * o, QEvent * e) { return callbackQWidget_EventFilter(this, o, e) != 0; };
	void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
	 ~MyQFocusFrame() { callbackQFocusFrame_DestroyQFocusFrame(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QFocusFrame*)
Q_DECLARE_METATYPE(MyQFocusFrame*)

int QFocusFrame_QFocusFrame_QRegisterMetaType(){qRegisterMetaType<QFocusFrame*>(); return qRegisterMetaType<MyQFocusFrame*>();}

void* QFocusFrame_NewQFocusFrame(void* parent)
{
		return new MyQFocusFrame(static_cast<QWidget*>(parent));
}

void QFocusFrame_InitStyleOption(void* ptr, void* option)
{
	static_cast<QFocusFrame*>(ptr)->initStyleOption(static_cast<QStyleOption*>(option));
}

void QFocusFrame_SetWidget(void* ptr, void* widget)
{
		static_cast<QFocusFrame*>(ptr)->setWidget(static_cast<QWidget*>(widget));
}

void* QFocusFrame_Widget(void* ptr)
{
	return static_cast<QFocusFrame*>(ptr)->widget();
}

void QFocusFrame_DestroyQFocusFrame(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->~QFocusFrame();
}

void QFocusFrame_DestroyQFocusFrameDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQFontComboBox: public QFontComboBox
{
public:
	MyQFontComboBox(QWidget *parent = Q_NULLPTR) : QFontComboBox(parent) {QFontComboBox_QFontComboBox_QRegisterMetaType();};
	void Signal_CurrentFontChanged(const QFont & font) { callbackQFontComboBox_CurrentFontChanged(this, const_cast<QFont*>(&font)); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void setCurrentFont(const QFont & ff) { callbackQFontComboBox_SetCurrentFont(this, const_cast<QFont*>(&ff)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQFontComboBox() { callbackQFontComboBox_DestroyQFontComboBox(this); };
	void Signal_Activated(int index) { callbackQComboBox_Activated(this, index); };
	void Signal_Activated2(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQComboBox_Activated2(this, textPacked); };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void clear() { callbackQComboBox_Clear(this); };
	void clearEditText() { callbackQComboBox_ClearEditText(this); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	void Signal_CurrentIndexChanged(int index) { callbackQComboBox_CurrentIndexChanged(this, index); };
	void Signal_CurrentTextChanged(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQComboBox_CurrentTextChanged(this, textPacked); };
	void Signal_EditTextChanged(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQComboBox_EditTextChanged(this, textPacked); };
	void focusInEvent(QFocusEvent * e) { callbackQWidget_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQWidget_FocusOutEvent(this, e); };
	void hideEvent(QHideEvent * e) { callbackQWidget_HideEvent(this, e); };
	void hidePopup() { callbackQComboBox_HidePopup(this); };
	void Signal_Highlighted(int index) { callbackQComboBox_Highlighted(this, index); };
	void Signal_Highlighted2(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQComboBox_Highlighted2(this, textPacked); };
	void inputMethodEvent(QInputMethodEvent * e) { callbackQWidget_InputMethodEvent(this, e); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQWidget_KeyReleaseEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQWidget_PaintEvent(this, e); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void setCurrentIndex(int index) { callbackQComboBox_SetCurrentIndex(this, index); };
	void setCurrentText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQComboBox_SetCurrentText(this, textPacked); };
	void setEditText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQComboBox_SetEditText(this, textPacked); };
	void showEvent(QShowEvent * e) { callbackQWidget_ShowEvent(this, e); };
	void showPopup() { callbackQComboBox_ShowPopup(this); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QFontComboBox*)
Q_DECLARE_METATYPE(MyQFontComboBox*)

int QFontComboBox_QFontComboBox_QRegisterMetaType(){qRegisterMetaType<QFontComboBox*>(); return qRegisterMetaType<MyQFontComboBox*>();}

void* QFontComboBox_NewQFontComboBox(void* parent)
{
		return new MyQFontComboBox(static_cast<QWidget*>(parent));
}

void* QFontComboBox_CurrentFont(void* ptr)
{
	return new QFont(static_cast<QFontComboBox*>(ptr)->currentFont());
}

void QFontComboBox_ConnectCurrentFontChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QFontComboBox*>(ptr), static_cast<void (QFontComboBox::*)(const QFont &)>(&QFontComboBox::currentFontChanged), static_cast<MyQFontComboBox*>(ptr), static_cast<void (MyQFontComboBox::*)(const QFont &)>(&MyQFontComboBox::Signal_CurrentFontChanged), static_cast<Qt::ConnectionType>(t));
}

void QFontComboBox_DisconnectCurrentFontChanged(void* ptr)
{
	QObject::disconnect(static_cast<QFontComboBox*>(ptr), static_cast<void (QFontComboBox::*)(const QFont &)>(&QFontComboBox::currentFontChanged), static_cast<MyQFontComboBox*>(ptr), static_cast<void (MyQFontComboBox::*)(const QFont &)>(&MyQFontComboBox::Signal_CurrentFontChanged));
}

void QFontComboBox_CurrentFontChanged(void* ptr, void* font)
{
	static_cast<QFontComboBox*>(ptr)->currentFontChanged(*static_cast<QFont*>(font));
}

long long QFontComboBox_FontFilters(void* ptr)
{
	return static_cast<QFontComboBox*>(ptr)->fontFilters();
}

void QFontComboBox_SetCurrentFont(void* ptr, void* ff)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setCurrentFont", Q_ARG(const QFont, *static_cast<QFont*>(ff)));
}

void QFontComboBox_SetCurrentFontDefault(void* ptr, void* ff)
{
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setCurrentFont(*static_cast<QFont*>(ff));
}

void QFontComboBox_SetFontFilters(void* ptr, long long filters)
{
	static_cast<QFontComboBox*>(ptr)->setFontFilters(static_cast<QFontComboBox::FontFilter>(filters));
}

void QFontComboBox_SetWritingSystem(void* ptr, long long vqf)
{
	static_cast<QFontComboBox*>(ptr)->setWritingSystem(static_cast<QFontDatabase::WritingSystem>(vqf));
}

void QFontComboBox_DestroyQFontComboBox(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->~QFontComboBox();
}

void QFontComboBox_DestroyQFontComboBoxDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQFontDialog: public QFontDialog
{
public:
	MyQFontDialog(QWidget *parent = Q_NULLPTR) : QFontDialog(parent) {QFontDialog_QFontDialog_QRegisterMetaType();};
	MyQFontDialog(const QFont &initial, QWidget *parent = Q_NULLPTR) : QFontDialog(initial, parent) {QFontDialog_QFontDialog_QRegisterMetaType();};
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void Signal_CurrentFontChanged(const QFont & font) { callbackQFontDialog_CurrentFontChanged(this, const_cast<QFont*>(&font)); };
	void done(int result) { callbackQFontDialog_Done(this, result); };
	void Signal_FontSelected(const QFont & font) { callbackQFontDialog_FontSelected(this, const_cast<QFont*>(&font)); };
	void setVisible(bool visible) { callbackQDialog_SetVisible(this, visible); };
	void accept() { callbackQDialog_Accept(this); };
	void Signal_Accepted() { callbackQDialog_Accepted(this); };
	void closeEvent(QCloseEvent * e) { callbackQWidget_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	bool eventFilter(QObject * o, QEvent * e) { return callbackQWidget_EventFilter(this, o, e) != 0; };
	int exec() { return callbackQDialog_Exec(this); };
	void Signal_Finished(int result) { callbackQDialog_Finished(this, result); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void reject() { callbackQDialog_Reject(this); };
	void Signal_Rejected() { callbackQDialog_Rejected(this); };
	void resizeEvent(QResizeEvent * vqr) { callbackQWidget_ResizeEvent(this, vqr); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QFontDialog*)
Q_DECLARE_METATYPE(MyQFontDialog*)

int QFontDialog_QFontDialog_QRegisterMetaType(){qRegisterMetaType<QFontDialog*>(); return qRegisterMetaType<MyQFontDialog*>();}

void* QFontDialog_NewQFontDialog(void* parent)
{
		return new MyQFontDialog(static_cast<QWidget*>(parent));
}

void* QFontDialog_NewQFontDialog2(void* initial, void* parent)
{
		return new MyQFontDialog(*static_cast<QFont*>(initial), static_cast<QWidget*>(parent));
}

void* QFontDialog_CurrentFont(void* ptr)
{
	return new QFont(static_cast<QFontDialog*>(ptr)->currentFont());
}

void QFontDialog_ConnectCurrentFontChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QFontDialog*>(ptr), static_cast<void (QFontDialog::*)(const QFont &)>(&QFontDialog::currentFontChanged), static_cast<MyQFontDialog*>(ptr), static_cast<void (MyQFontDialog::*)(const QFont &)>(&MyQFontDialog::Signal_CurrentFontChanged), static_cast<Qt::ConnectionType>(t));
}

void QFontDialog_DisconnectCurrentFontChanged(void* ptr)
{
	QObject::disconnect(static_cast<QFontDialog*>(ptr), static_cast<void (QFontDialog::*)(const QFont &)>(&QFontDialog::currentFontChanged), static_cast<MyQFontDialog*>(ptr), static_cast<void (MyQFontDialog::*)(const QFont &)>(&MyQFontDialog::Signal_CurrentFontChanged));
}

void QFontDialog_CurrentFontChanged(void* ptr, void* font)
{
	static_cast<QFontDialog*>(ptr)->currentFontChanged(*static_cast<QFont*>(font));
}

void QFontDialog_Done(void* ptr, int result)
{
	static_cast<QFontDialog*>(ptr)->done(result);
}

void QFontDialog_DoneDefault(void* ptr, int result)
{
		static_cast<QFontDialog*>(ptr)->QFontDialog::done(result);
}

void QFontDialog_ConnectFontSelected(void* ptr, long long t)
{
	QObject::connect(static_cast<QFontDialog*>(ptr), static_cast<void (QFontDialog::*)(const QFont &)>(&QFontDialog::fontSelected), static_cast<MyQFontDialog*>(ptr), static_cast<void (MyQFontDialog::*)(const QFont &)>(&MyQFontDialog::Signal_FontSelected), static_cast<Qt::ConnectionType>(t));
}

void QFontDialog_DisconnectFontSelected(void* ptr)
{
	QObject::disconnect(static_cast<QFontDialog*>(ptr), static_cast<void (QFontDialog::*)(const QFont &)>(&QFontDialog::fontSelected), static_cast<MyQFontDialog*>(ptr), static_cast<void (MyQFontDialog::*)(const QFont &)>(&MyQFontDialog::Signal_FontSelected));
}

void QFontDialog_FontSelected(void* ptr, void* font)
{
	static_cast<QFontDialog*>(ptr)->fontSelected(*static_cast<QFont*>(font));
}

void* QFontDialog_QFontDialog_GetFont(char* ok, void* initial, void* parent, struct QtWidgets_PackedString title, long long options)
{
		return new QFont(QFontDialog::getFont(reinterpret_cast<bool*>(ok), *static_cast<QFont*>(initial), static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len), static_cast<QFontDialog::FontDialogOption>(options)));
}

void* QFontDialog_QFontDialog_GetFont2(char* ok, void* parent)
{
		return new QFont(QFontDialog::getFont(reinterpret_cast<bool*>(ok), static_cast<QWidget*>(parent)));
}

void QFontDialog_Open(void* ptr, void* receiver, char* member)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(receiver))) {
		static_cast<QFontDialog*>(ptr)->open(static_cast<QGraphicsObject*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(receiver))) {
		static_cast<QFontDialog*>(ptr)->open(static_cast<QGraphicsWidget*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(receiver))) {
		static_cast<QFontDialog*>(ptr)->open(static_cast<QLayout*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(receiver))) {
		static_cast<QFontDialog*>(ptr)->open(static_cast<QWidget*>(receiver), const_cast<const char*>(member));
	} else {
		static_cast<QFontDialog*>(ptr)->open(static_cast<QObject*>(receiver), const_cast<const char*>(member));
	}
}

long long QFontDialog_Options(void* ptr)
{
	return static_cast<QFontDialog*>(ptr)->options();
}

void* QFontDialog_SelectedFont(void* ptr)
{
	return new QFont(static_cast<QFontDialog*>(ptr)->selectedFont());
}

void QFontDialog_SetCurrentFont(void* ptr, void* font)
{
	static_cast<QFontDialog*>(ptr)->setCurrentFont(*static_cast<QFont*>(font));
}

void QFontDialog_SetOption(void* ptr, long long option, char on)
{
	static_cast<QFontDialog*>(ptr)->setOption(static_cast<QFontDialog::FontDialogOption>(option), on != 0);
}

void QFontDialog_SetOptions(void* ptr, long long options)
{
	static_cast<QFontDialog*>(ptr)->setOptions(static_cast<QFontDialog::FontDialogOption>(options));
}

char QFontDialog_TestOption(void* ptr, long long option)
{
	return static_cast<QFontDialog*>(ptr)->testOption(static_cast<QFontDialog::FontDialogOption>(option));
}

class MyQFormLayout: public QFormLayout
{
public:
	MyQFormLayout(QWidget *parent = Q_NULLPTR) : QFormLayout(parent) {QFormLayout_QFormLayout_QRegisterMetaType();};
	void addItem(QLayoutItem * item) { callbackQFormLayout_AddItem(this, item); };
	int count() const { return callbackQFormLayout_Count(const_cast<void*>(static_cast<const void*>(this))); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQLayout_ExpandingDirections(const_cast<void*>(static_cast<const void*>(this)))); };
	bool hasHeightForWidth() const { return callbackQLayoutItem_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int width) const { return callbackQLayoutItem_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), width); };
	void invalidate() { callbackQLayoutItem_Invalidate(this); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQLayout_MinimumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	void setGeometry(const QRect & rect) { callbackQLayout_SetGeometry(this, const_cast<QRect*>(&rect)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQFormLayout_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQFormLayout_TakeAt(this, index)); };
	 ~MyQFormLayout() { callbackQFormLayout_DestroyQFormLayout(this); };
	void childEvent(QChildEvent * e) { callbackQLayout_ChildEvent(this, e); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayoutItem_ControlTypes(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQLayout_Geometry(const_cast<void*>(static_cast<const void*>(this)))); };
	int indexOf(QWidget * widget) const { return callbackQLayout_IndexOf(const_cast<void*>(static_cast<const void*>(this)), widget); };
	bool isEmpty() const { return callbackQLayout_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QLayout * layout() { return static_cast<QLayout*>(callbackQLayoutItem_Layout(this)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQLayout_MaximumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	void connectNotify(const QMetaMethod & sign) { callbackQLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQLayout_CustomEvent(this, event); };
	void deleteLater() { callbackQLayout_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQLayout_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQLayout_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQLayout_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLayout_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQLayout_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQLayout_TimerEvent(this, event); };
	int minimumHeightForWidth(int w) const { return callbackQLayoutItem_MinimumHeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayoutItem_SpacerItem(this)); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQLayoutItem_Widget(this)); };
};

Q_DECLARE_METATYPE(QFormLayout*)
Q_DECLARE_METATYPE(MyQFormLayout*)

int QFormLayout_QFormLayout_QRegisterMetaType(){qRegisterMetaType<QFormLayout*>(); return qRegisterMetaType<MyQFormLayout*>();}

void* QFormLayout_NewQFormLayout(void* parent)
{
		return new MyQFormLayout(static_cast<QWidget*>(parent));
}

void QFormLayout_AddItem(void* ptr, void* item)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
		static_cast<QFormLayout*>(ptr)->addItem(static_cast<QLayout*>(item));
	} else {
		static_cast<QFormLayout*>(ptr)->addItem(static_cast<QLayoutItem*>(item));
	}
}

void QFormLayout_AddItemDefault(void* ptr, void* item)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
		static_cast<QFormLayout*>(ptr)->QFormLayout::addItem(static_cast<QLayout*>(item));
	} else {
		static_cast<QFormLayout*>(ptr)->QFormLayout::addItem(static_cast<QLayoutItem*>(item));
	}
}

void QFormLayout_AddRow(void* ptr, void* label, void* field)
{
		static_cast<QFormLayout*>(ptr)->addRow(static_cast<QWidget*>(label), static_cast<QWidget*>(field));
}

void QFormLayout_AddRow2(void* ptr, void* label, void* field)
{
		static_cast<QFormLayout*>(ptr)->addRow(static_cast<QWidget*>(label), static_cast<QLayout*>(field));
}

void QFormLayout_AddRow3(void* ptr, struct QtWidgets_PackedString labelText, void* field)
{
		static_cast<QFormLayout*>(ptr)->addRow(QString::fromUtf8(labelText.data, labelText.len), static_cast<QWidget*>(field));
}

void QFormLayout_AddRow4(void* ptr, struct QtWidgets_PackedString labelText, void* field)
{
		static_cast<QFormLayout*>(ptr)->addRow(QString::fromUtf8(labelText.data, labelText.len), static_cast<QLayout*>(field));
}

void QFormLayout_AddRow5(void* ptr, void* widget)
{
		static_cast<QFormLayout*>(ptr)->addRow(static_cast<QWidget*>(widget));
}

void QFormLayout_AddRow6(void* ptr, void* layout)
{
		static_cast<QFormLayout*>(ptr)->addRow(static_cast<QLayout*>(layout));
}

int QFormLayout_Count(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->count();
}

int QFormLayout_CountDefault(void* ptr)
{
		return static_cast<QFormLayout*>(ptr)->QFormLayout::count();
}

long long QFormLayout_FieldGrowthPolicy(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->fieldGrowthPolicy();
}

long long QFormLayout_FormAlignment(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->formAlignment();
}

int QFormLayout_HorizontalSpacing(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->horizontalSpacing();
}

void QFormLayout_InsertRow(void* ptr, int row, void* label, void* field)
{
		static_cast<QFormLayout*>(ptr)->insertRow(row, static_cast<QWidget*>(label), static_cast<QWidget*>(field));
}

void QFormLayout_InsertRow2(void* ptr, int row, void* label, void* field)
{
		static_cast<QFormLayout*>(ptr)->insertRow(row, static_cast<QWidget*>(label), static_cast<QLayout*>(field));
}

void QFormLayout_InsertRow3(void* ptr, int row, struct QtWidgets_PackedString labelText, void* field)
{
		static_cast<QFormLayout*>(ptr)->insertRow(row, QString::fromUtf8(labelText.data, labelText.len), static_cast<QWidget*>(field));
}

void QFormLayout_InsertRow4(void* ptr, int row, struct QtWidgets_PackedString labelText, void* field)
{
		static_cast<QFormLayout*>(ptr)->insertRow(row, QString::fromUtf8(labelText.data, labelText.len), static_cast<QLayout*>(field));
}

void QFormLayout_InsertRow5(void* ptr, int row, void* widget)
{
		static_cast<QFormLayout*>(ptr)->insertRow(row, static_cast<QWidget*>(widget));
}

void QFormLayout_InsertRow6(void* ptr, int row, void* layout)
{
		static_cast<QFormLayout*>(ptr)->insertRow(row, static_cast<QLayout*>(layout));
}

long long QFormLayout_LabelAlignment(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->labelAlignment();
}

void* QFormLayout_LabelForField(void* ptr, void* field)
{
		return static_cast<QFormLayout*>(ptr)->labelForField(static_cast<QWidget*>(field));
}

void* QFormLayout_LabelForField2(void* ptr, void* field)
{
		return static_cast<QFormLayout*>(ptr)->labelForField(static_cast<QLayout*>(field));
}

void QFormLayout_RemoveRow(void* ptr, int row)
{
	static_cast<QFormLayout*>(ptr)->removeRow(row);
}

void QFormLayout_RemoveRow2(void* ptr, void* widget)
{
		static_cast<QFormLayout*>(ptr)->removeRow(static_cast<QWidget*>(widget));
}

void QFormLayout_RemoveRow3(void* ptr, void* layout)
{
		static_cast<QFormLayout*>(ptr)->removeRow(static_cast<QLayout*>(layout));
}

int QFormLayout_RowCount(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->rowCount();
}

long long QFormLayout_RowWrapPolicy(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->rowWrapPolicy();
}

void QFormLayout_SetFieldGrowthPolicy(void* ptr, long long policy)
{
	static_cast<QFormLayout*>(ptr)->setFieldGrowthPolicy(static_cast<QFormLayout::FieldGrowthPolicy>(policy));
}

void QFormLayout_SetFormAlignment(void* ptr, long long alignment)
{
	static_cast<QFormLayout*>(ptr)->setFormAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}

void QFormLayout_SetHorizontalSpacing(void* ptr, int spacing)
{
	static_cast<QFormLayout*>(ptr)->setHorizontalSpacing(spacing);
}

void QFormLayout_SetItem(void* ptr, int row, long long role, void* item)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
		static_cast<QFormLayout*>(ptr)->setItem(row, static_cast<QFormLayout::ItemRole>(role), static_cast<QLayout*>(item));
	} else {
		static_cast<QFormLayout*>(ptr)->setItem(row, static_cast<QFormLayout::ItemRole>(role), static_cast<QLayoutItem*>(item));
	}
}

void QFormLayout_SetLabelAlignment(void* ptr, long long alignment)
{
	static_cast<QFormLayout*>(ptr)->setLabelAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}

void QFormLayout_SetLayout(void* ptr, int row, long long role, void* layout)
{
		static_cast<QFormLayout*>(ptr)->setLayout(row, static_cast<QFormLayout::ItemRole>(role), static_cast<QLayout*>(layout));
}

void QFormLayout_SetRowWrapPolicy(void* ptr, long long policy)
{
	static_cast<QFormLayout*>(ptr)->setRowWrapPolicy(static_cast<QFormLayout::RowWrapPolicy>(policy));
}

void QFormLayout_SetVerticalSpacing(void* ptr, int spacing)
{
	static_cast<QFormLayout*>(ptr)->setVerticalSpacing(spacing);
}

void QFormLayout_SetWidget(void* ptr, int row, long long role, void* widget)
{
		static_cast<QFormLayout*>(ptr)->setWidget(row, static_cast<QFormLayout::ItemRole>(role), static_cast<QWidget*>(widget));
}

void* QFormLayout_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFormLayout*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QFormLayout_SizeHintDefault(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QFormLayout*>(ptr)->QFormLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QFormLayout_TakeAt(void* ptr, int index)
{
	return static_cast<QFormLayout*>(ptr)->takeAt(index);
}

void* QFormLayout_TakeAtDefault(void* ptr, int index)
{
		return static_cast<QFormLayout*>(ptr)->QFormLayout::takeAt(index);
}

int QFormLayout_VerticalSpacing(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->verticalSpacing();
}

void QFormLayout_DestroyQFormLayout(void* ptr)
{
	static_cast<QFormLayout*>(ptr)->~QFormLayout();
}

void QFormLayout_DestroyQFormLayoutDefault(void* ptr)
{
	Q_UNUSED(ptr);

}





class MyQFrame: public QFrame
{
public:
	MyQFrame(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QFrame(parent, ff) {QFrame_QFrame_QRegisterMetaType();};
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQFrame() { callbackQFrame_DestroyQFrame(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QFrame*)
Q_DECLARE_METATYPE(MyQFrame*)

int QFrame_QFrame_QRegisterMetaType(){qRegisterMetaType<QFrame*>(); return qRegisterMetaType<MyQFrame*>();}

void* QFrame_NewQFrame(void* parent, long long ff)
{
		return new MyQFrame(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}

void* QFrame_FrameRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QFrame*>(ptr)->frameRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

long long QFrame_FrameShadow(void* ptr)
{
	return static_cast<QFrame*>(ptr)->frameShadow();
}

long long QFrame_FrameShape(void* ptr)
{
	return static_cast<QFrame*>(ptr)->frameShape();
}

int QFrame_FrameStyle(void* ptr)
{
	return static_cast<QFrame*>(ptr)->frameStyle();
}

int QFrame_FrameWidth(void* ptr)
{
	return static_cast<QFrame*>(ptr)->frameWidth();
}

void QFrame_InitStyleOption(void* ptr, void* option)
{
	static_cast<QFrame*>(ptr)->initStyleOption(static_cast<QStyleOptionFrame*>(option));
}

int QFrame_LineWidth(void* ptr)
{
	return static_cast<QFrame*>(ptr)->lineWidth();
}

int QFrame_MidLineWidth(void* ptr)
{
	return static_cast<QFrame*>(ptr)->midLineWidth();
}

void QFrame_SetFrameRect(void* ptr, void* vqr)
{
	static_cast<QFrame*>(ptr)->setFrameRect(*static_cast<QRect*>(vqr));
}

void QFrame_SetFrameShadow(void* ptr, long long vqf)
{
	static_cast<QFrame*>(ptr)->setFrameShadow(static_cast<QFrame::Shadow>(vqf));
}

void QFrame_SetFrameShape(void* ptr, long long vqf)
{
	static_cast<QFrame*>(ptr)->setFrameShape(static_cast<QFrame::Shape>(vqf));
}

void QFrame_SetFrameStyle(void* ptr, int style)
{
	static_cast<QFrame*>(ptr)->setFrameStyle(style);
}

void QFrame_SetLineWidth(void* ptr, int vin)
{
	static_cast<QFrame*>(ptr)->setLineWidth(vin);
}

void QFrame_SetMidLineWidth(void* ptr, int vin)
{
	static_cast<QFrame*>(ptr)->setMidLineWidth(vin);
}

void QFrame_DestroyQFrame(void* ptr)
{
	static_cast<QFrame*>(ptr)->~QFrame();
}

void QFrame_DestroyQFrameDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGesture: public QGesture
{
public:
	MyQGesture(QObject *parent = Q_NULLPTR) : QGesture(parent) {QGesture_QGesture_QRegisterMetaType();};
	 ~MyQGesture() { callbackQGesture_DestroyQGesture(this); };
	void childEvent(QChildEvent * event) { callbackQGesture_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGesture_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGesture_CustomEvent(this, event); };
	void deleteLater() { callbackQGesture_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGesture_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGesture_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGesture_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGesture_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGesture_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGesture_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGesture_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGesture*)
Q_DECLARE_METATYPE(MyQGesture*)

int QGesture_QGesture_QRegisterMetaType(){qRegisterMetaType<QGesture*>(); return qRegisterMetaType<MyQGesture*>();}

void* QGesture_NewQGesture(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGesture(static_cast<QWindow*>(parent));
	} else {
		return new MyQGesture(static_cast<QObject*>(parent));
	}
}

long long QGesture_GestureCancelPolicy(void* ptr)
{
	return static_cast<QGesture*>(ptr)->gestureCancelPolicy();
}

long long QGesture_GestureType(void* ptr)
{
	return static_cast<QGesture*>(ptr)->gestureType();
}

char QGesture_HasHotSpot(void* ptr)
{
	return static_cast<QGesture*>(ptr)->hasHotSpot();
}

void* QGesture_HotSpot(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGesture*>(ptr)->hotSpot(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QGesture_SetGestureCancelPolicy(void* ptr, long long policy)
{
	static_cast<QGesture*>(ptr)->setGestureCancelPolicy(static_cast<QGesture::GestureCancelPolicy>(policy));
}

void QGesture_SetHotSpot(void* ptr, void* value)
{
	static_cast<QGesture*>(ptr)->setHotSpot(*static_cast<QPointF*>(value));
}

long long QGesture_State(void* ptr)
{
	return static_cast<QGesture*>(ptr)->state();
}

void QGesture_UnsetHotSpot(void* ptr)
{
	static_cast<QGesture*>(ptr)->unsetHotSpot();
}

void QGesture_DestroyQGesture(void* ptr)
{
	static_cast<QGesture*>(ptr)->~QGesture();
}

void QGesture_DestroyQGestureDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QGesture___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGesture___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QGesture___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QGesture___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGesture___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QGesture___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGesture___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void QGesture_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QTapGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QTapGesture*>(ptr)->QTapGesture::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QSwipeGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QPinchGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QPinchGesture*>(ptr)->QPinchGesture::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QPanGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QPanGesture*>(ptr)->QPanGesture::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QTapAndHoldGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QGesture*>(ptr)->QGesture::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QGesture_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QTapGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QTapGesture*>(ptr)->QTapGesture::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSwipeGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QPinchGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QPinchGesture*>(ptr)->QPinchGesture::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QPanGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QPanGesture*>(ptr)->QPanGesture::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTapAndHoldGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QGesture*>(ptr)->QGesture::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QGesture_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QTapGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QTapGesture*>(ptr)->QTapGesture::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSwipeGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPinchGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QPinchGesture*>(ptr)->QPinchGesture::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPanGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QPanGesture*>(ptr)->QPanGesture::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTapAndHoldGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QGesture*>(ptr)->QGesture::customEvent(static_cast<QEvent*>(event));
	}
}

void QGesture_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QTapGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QTapGesture*>(ptr)->QTapGesture::deleteLater();
	} else if (dynamic_cast<QSwipeGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::deleteLater();
	} else if (dynamic_cast<QPinchGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QPinchGesture*>(ptr)->QPinchGesture::deleteLater();
	} else if (dynamic_cast<QPanGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QPanGesture*>(ptr)->QPanGesture::deleteLater();
	} else if (dynamic_cast<QTapAndHoldGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::deleteLater();
	} else {
		static_cast<QGesture*>(ptr)->QGesture::deleteLater();
	}
}

void QGesture_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QTapGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QTapGesture*>(ptr)->QTapGesture::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSwipeGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QPinchGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QPinchGesture*>(ptr)->QPinchGesture::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QPanGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QPanGesture*>(ptr)->QPanGesture::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTapAndHoldGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QGesture*>(ptr)->QGesture::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

char QGesture_EventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QTapGesture*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTapGesture*>(ptr)->QTapGesture::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QSwipeGesture*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QPinchGesture*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPinchGesture*>(ptr)->QPinchGesture::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QPanGesture*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPanGesture*>(ptr)->QPanGesture::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QTapAndHoldGesture*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::event(static_cast<QEvent*>(e));
	} else {
		return static_cast<QGesture*>(ptr)->QGesture::event(static_cast<QEvent*>(e));
	}
}

char QGesture_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QTapGesture*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QTapGesture*>(ptr)->QTapGesture::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTapGesture*>(ptr)->QTapGesture::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QTapGesture*>(ptr)->QTapGesture::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTapGesture*>(ptr)->QTapGesture::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTapGesture*>(ptr)->QTapGesture::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QSwipeGesture*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QPinchGesture*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QPinchGesture*>(ptr)->QPinchGesture::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QPinchGesture*>(ptr)->QPinchGesture::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QPinchGesture*>(ptr)->QPinchGesture::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QPinchGesture*>(ptr)->QPinchGesture::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QPinchGesture*>(ptr)->QPinchGesture::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QPanGesture*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QPanGesture*>(ptr)->QPanGesture::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QPanGesture*>(ptr)->QPanGesture::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QPanGesture*>(ptr)->QPanGesture::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QPanGesture*>(ptr)->QPanGesture::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QPanGesture*>(ptr)->QPanGesture::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QTapAndHoldGesture*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGesture*>(ptr)->QGesture::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGesture*>(ptr)->QGesture::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGesture*>(ptr)->QGesture::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGesture*>(ptr)->QGesture::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGesture*>(ptr)->QGesture::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void* QGesture_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QTapGesture*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTapGesture*>(ptr)->QTapGesture::metaObject());
	} else if (dynamic_cast<QSwipeGesture*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::metaObject());
	} else if (dynamic_cast<QPinchGesture*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QPinchGesture*>(ptr)->QPinchGesture::metaObject());
	} else if (dynamic_cast<QPanGesture*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QPanGesture*>(ptr)->QPanGesture::metaObject());
	} else if (dynamic_cast<QTapAndHoldGesture*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QGesture*>(ptr)->QGesture::metaObject());
	}
}

void QGesture_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QTapGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QTapGesture*>(ptr)->QTapGesture::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QSwipeGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QPinchGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QPinchGesture*>(ptr)->QPinchGesture::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QPanGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QPanGesture*>(ptr)->QPanGesture::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QTapAndHoldGesture*>(static_cast<QObject*>(ptr))) {
		static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QGesture*>(ptr)->QGesture::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

class MyQGestureEvent: public QGestureEvent
{
public:
	MyQGestureEvent(const QList<QGesture *> &gestures) : QGestureEvent(gestures) {QGestureEvent_QGestureEvent_QRegisterMetaType();};
	 ~MyQGestureEvent() { callbackQGestureEvent_DestroyQGestureEvent(this); };
};

Q_DECLARE_METATYPE(QGestureEvent*)
Q_DECLARE_METATYPE(MyQGestureEvent*)

int QGestureEvent_QGestureEvent_QRegisterMetaType(){qRegisterMetaType<QGestureEvent*>(); return qRegisterMetaType<MyQGestureEvent*>();}

void* QGestureEvent_NewQGestureEvent(void* gestures)
{
	return new MyQGestureEvent(*static_cast<QList<QGesture *>*>(gestures));
}

void QGestureEvent_Accept(void* ptr, void* gesture)
{
	static_cast<QGestureEvent*>(ptr)->accept(static_cast<QGesture*>(gesture));
}

void QGestureEvent_Accept2(void* ptr, long long gestureType)
{
	static_cast<QGestureEvent*>(ptr)->accept(static_cast<Qt::GestureType>(gestureType));
}

struct QtWidgets_PackedList QGestureEvent_ActiveGestures(void* ptr)
{
	return ({ QList<QGesture *>* tmpValuef47832 = new QList<QGesture *>(static_cast<QGestureEvent*>(ptr)->activeGestures()); QtWidgets_PackedList { tmpValuef47832, tmpValuef47832->size() }; });
}

struct QtWidgets_PackedList QGestureEvent_CanceledGestures(void* ptr)
{
	return ({ QList<QGesture *>* tmpValue4c99df = new QList<QGesture *>(static_cast<QGestureEvent*>(ptr)->canceledGestures()); QtWidgets_PackedList { tmpValue4c99df, tmpValue4c99df->size() }; });
}

void* QGestureEvent_Gesture(void* ptr, long long ty)
{
	return static_cast<QGestureEvent*>(ptr)->gesture(static_cast<Qt::GestureType>(ty));
}

struct QtWidgets_PackedList QGestureEvent_Gestures(void* ptr)
{
	return ({ QList<QGesture *>* tmpValue9ee128 = new QList<QGesture *>(static_cast<QGestureEvent*>(ptr)->gestures()); QtWidgets_PackedList { tmpValue9ee128, tmpValue9ee128->size() }; });
}

void QGestureEvent_Ignore(void* ptr, void* gesture)
{
	static_cast<QGestureEvent*>(ptr)->ignore(static_cast<QGesture*>(gesture));
}

void QGestureEvent_Ignore2(void* ptr, long long gestureType)
{
	static_cast<QGestureEvent*>(ptr)->ignore(static_cast<Qt::GestureType>(gestureType));
}

char QGestureEvent_IsAccepted(void* ptr, void* gesture)
{
	return static_cast<QGestureEvent*>(ptr)->isAccepted(static_cast<QGesture*>(gesture));
}

char QGestureEvent_IsAccepted2(void* ptr, long long gestureType)
{
	return static_cast<QGestureEvent*>(ptr)->isAccepted(static_cast<Qt::GestureType>(gestureType));
}

void* QGestureEvent_MapToGraphicsScene(void* ptr, void* gesturePoint)
{
	return ({ QPointF tmpValue = static_cast<QGestureEvent*>(ptr)->mapToGraphicsScene(*static_cast<QPointF*>(gesturePoint)); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QGestureEvent_SetAccepted(void* ptr, void* gesture, char value)
{
	static_cast<QGestureEvent*>(ptr)->setAccepted(static_cast<QGesture*>(gesture), value != 0);
}

void QGestureEvent_SetAccepted2(void* ptr, long long gestureType, char value)
{
	static_cast<QGestureEvent*>(ptr)->setAccepted(static_cast<Qt::GestureType>(gestureType), value != 0);
}

void* QGestureEvent_Widget(void* ptr)
{
	return static_cast<QGestureEvent*>(ptr)->widget();
}

void QGestureEvent_DestroyQGestureEvent(void* ptr)
{
	static_cast<QGestureEvent*>(ptr)->~QGestureEvent();
}

void QGestureEvent_DestroyQGestureEventDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QGestureEvent___QGestureEvent_gestures_atList(void* ptr, int i)
{
	return ({QGesture * tmp = static_cast<QList<QGesture *>*>(ptr)->at(i); if (i == static_cast<QList<QGesture *>*>(ptr)->size()-1) { static_cast<QList<QGesture *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QGestureEvent___QGestureEvent_gestures_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGesture *>();
}

void* QGestureEvent___activeGestures_atList(void* ptr, int i)
{
	return ({QGesture * tmp = static_cast<QList<QGesture *>*>(ptr)->at(i); if (i == static_cast<QList<QGesture *>*>(ptr)->size()-1) { static_cast<QList<QGesture *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QGestureEvent___activeGestures_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGesture *>();
}

void* QGestureEvent___canceledGestures_atList(void* ptr, int i)
{
	return ({QGesture * tmp = static_cast<QList<QGesture *>*>(ptr)->at(i); if (i == static_cast<QList<QGesture *>*>(ptr)->size()-1) { static_cast<QList<QGesture *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QGestureEvent___canceledGestures_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGesture *>();
}

void* QGestureEvent___gestures_atList(void* ptr, int i)
{
	return ({QGesture * tmp = static_cast<QList<QGesture *>*>(ptr)->at(i); if (i == static_cast<QList<QGesture *>*>(ptr)->size()-1) { static_cast<QList<QGesture *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QGestureEvent___gestures_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGesture *>();
}

void* QGestureEvent___m_gestures_atList(void* ptr, int i)
{
	return ({QGesture * tmp = static_cast<QList<QGesture *>*>(ptr)->at(i); if (i == static_cast<QList<QGesture *>*>(ptr)->size()-1) { static_cast<QList<QGesture *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QGestureEvent___m_gestures_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGesture *>();
}

void* QGestureEvent___setM_gestures__atList(void* ptr, int i)
{
	return ({QGesture * tmp = static_cast<QList<QGesture *>*>(ptr)->at(i); if (i == static_cast<QList<QGesture *>*>(ptr)->size()-1) { static_cast<QList<QGesture *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QGestureEvent___setM_gestures__newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGesture *>();
}

char QGestureEvent___m_accepted_atList(void* ptr, long long v, int i)
{
	return ({ bool tmp = static_cast<QMap<Qt::GestureType, bool>*>(ptr)->value(static_cast<Qt::GestureType>(v)); if (i == static_cast<QMap<Qt::GestureType, bool>*>(ptr)->size()-1) { static_cast<QMap<Qt::GestureType, bool>*>(ptr)->~QMap(); free(ptr); }; tmp; });
}

void QGestureEvent___m_accepted_setList(void* ptr, long long key, char i)
{
	static_cast<QMap<Qt::GestureType, bool>*>(ptr)->insert(static_cast<Qt::GestureType>(key), i != 0);
}

void* QGestureEvent___m_accepted_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<Qt::GestureType, bool>();
}

struct QtWidgets_PackedList QGestureEvent___m_accepted_keyList(void* ptr)
{
	return ({ QList<Qt::GestureType>* tmpValue749853 = new QList<Qt::GestureType>(static_cast<QMap<Qt::GestureType, bool>*>(ptr)->keys()); QtWidgets_PackedList { tmpValue749853, tmpValue749853->size() }; });
}

char QGestureEvent___setM_accepted__atList(void* ptr, long long v, int i)
{
	return ({ bool tmp = static_cast<QMap<Qt::GestureType, bool>*>(ptr)->value(static_cast<Qt::GestureType>(v)); if (i == static_cast<QMap<Qt::GestureType, bool>*>(ptr)->size()-1) { static_cast<QMap<Qt::GestureType, bool>*>(ptr)->~QMap(); free(ptr); }; tmp; });
}

void QGestureEvent___setM_accepted__setList(void* ptr, long long key, char i)
{
	static_cast<QMap<Qt::GestureType, bool>*>(ptr)->insert(static_cast<Qt::GestureType>(key), i != 0);
}

void* QGestureEvent___setM_accepted__newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<Qt::GestureType, bool>();
}

struct QtWidgets_PackedList QGestureEvent___setM_accepted__keyList(void* ptr)
{
	return ({ QList<Qt::GestureType>* tmpValue749853 = new QList<Qt::GestureType>(static_cast<QMap<Qt::GestureType, bool>*>(ptr)->keys()); QtWidgets_PackedList { tmpValue749853, tmpValue749853->size() }; });
}

void* QGestureEvent___m_targetWidgets_atList(void* ptr, long long v, int i)
{
	return ({ QWidget * tmp = static_cast<QMap<Qt::GestureType, QWidget *>*>(ptr)->value(static_cast<Qt::GestureType>(v)); if (i == static_cast<QMap<Qt::GestureType, QWidget *>*>(ptr)->size()-1) { static_cast<QMap<Qt::GestureType, QWidget *>*>(ptr)->~QMap(); free(ptr); }; tmp; });
}

void QGestureEvent___m_targetWidgets_setList(void* ptr, long long key, void* i)
{
		static_cast<QMap<Qt::GestureType, QWidget *>*>(ptr)->insert(static_cast<Qt::GestureType>(key), static_cast<QWidget*>(i));
}

void* QGestureEvent___m_targetWidgets_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<Qt::GestureType, QWidget *>();
}

struct QtWidgets_PackedList QGestureEvent___m_targetWidgets_keyList(void* ptr)
{
	return ({ QList<Qt::GestureType>* tmpValued4ffd2 = new QList<Qt::GestureType>(static_cast<QMap<Qt::GestureType, QWidget *>*>(ptr)->keys()); QtWidgets_PackedList { tmpValued4ffd2, tmpValued4ffd2->size() }; });
}

void* QGestureEvent___setM_targetWidgets__atList(void* ptr, long long v, int i)
{
	return ({ QWidget * tmp = static_cast<QMap<Qt::GestureType, QWidget *>*>(ptr)->value(static_cast<Qt::GestureType>(v)); if (i == static_cast<QMap<Qt::GestureType, QWidget *>*>(ptr)->size()-1) { static_cast<QMap<Qt::GestureType, QWidget *>*>(ptr)->~QMap(); free(ptr); }; tmp; });
}

void QGestureEvent___setM_targetWidgets__setList(void* ptr, long long key, void* i)
{
		static_cast<QMap<Qt::GestureType, QWidget *>*>(ptr)->insert(static_cast<Qt::GestureType>(key), static_cast<QWidget*>(i));
}

void* QGestureEvent___setM_targetWidgets__newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QMap<Qt::GestureType, QWidget *>();
}

struct QtWidgets_PackedList QGestureEvent___setM_targetWidgets__keyList(void* ptr)
{
	return ({ QList<Qt::GestureType>* tmpValued4ffd2 = new QList<Qt::GestureType>(static_cast<QMap<Qt::GestureType, QWidget *>*>(ptr)->keys()); QtWidgets_PackedList { tmpValued4ffd2, tmpValued4ffd2->size() }; });
}

long long QGestureEvent_____m_accepted_keyList_atList(void* ptr, int i)
{
	return ({Qt::GestureType tmp = static_cast<QList<Qt::GestureType>*>(ptr)->at(i); if (i == static_cast<QList<Qt::GestureType>*>(ptr)->size()-1) { static_cast<QList<Qt::GestureType>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGestureEvent_____m_accepted_keyList_setList(void* ptr, long long i)
{
	static_cast<QList<Qt::GestureType>*>(ptr)->append(static_cast<Qt::GestureType>(i));
}

void* QGestureEvent_____m_accepted_keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<Qt::GestureType>();
}

long long QGestureEvent_____setM_accepted__keyList_atList(void* ptr, int i)
{
	return ({Qt::GestureType tmp = static_cast<QList<Qt::GestureType>*>(ptr)->at(i); if (i == static_cast<QList<Qt::GestureType>*>(ptr)->size()-1) { static_cast<QList<Qt::GestureType>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGestureEvent_____setM_accepted__keyList_setList(void* ptr, long long i)
{
	static_cast<QList<Qt::GestureType>*>(ptr)->append(static_cast<Qt::GestureType>(i));
}

void* QGestureEvent_____setM_accepted__keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<Qt::GestureType>();
}

long long QGestureEvent_____m_targetWidgets_keyList_atList(void* ptr, int i)
{
	return ({Qt::GestureType tmp = static_cast<QList<Qt::GestureType>*>(ptr)->at(i); if (i == static_cast<QList<Qt::GestureType>*>(ptr)->size()-1) { static_cast<QList<Qt::GestureType>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGestureEvent_____m_targetWidgets_keyList_setList(void* ptr, long long i)
{
	static_cast<QList<Qt::GestureType>*>(ptr)->append(static_cast<Qt::GestureType>(i));
}

void* QGestureEvent_____m_targetWidgets_keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<Qt::GestureType>();
}

long long QGestureEvent_____setM_targetWidgets__keyList_atList(void* ptr, int i)
{
	return ({Qt::GestureType tmp = static_cast<QList<Qt::GestureType>*>(ptr)->at(i); if (i == static_cast<QList<Qt::GestureType>*>(ptr)->size()-1) { static_cast<QList<Qt::GestureType>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGestureEvent_____setM_targetWidgets__keyList_setList(void* ptr, long long i)
{
	static_cast<QList<Qt::GestureType>*>(ptr)->append(static_cast<Qt::GestureType>(i));
}

void* QGestureEvent_____setM_targetWidgets__keyList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<Qt::GestureType>();
}

class MyQGestureRecognizer: public QGestureRecognizer
{
public:
	MyQGestureRecognizer() : QGestureRecognizer() {QGestureRecognizer_QGestureRecognizer_QRegisterMetaType();};
	QGesture * create(QObject * target) { return static_cast<QGesture*>(callbackQGestureRecognizer_Create(this, target)); };
	QGestureRecognizer::Result recognize(QGesture * gesture, QObject * watched, QEvent * event) { return static_cast<QGestureRecognizer::ResultFlag>(callbackQGestureRecognizer_Recognize(this, gesture, watched, event)); };
	void reset(QGesture * gesture) { callbackQGestureRecognizer_Reset(this, gesture); };
	 ~MyQGestureRecognizer() { callbackQGestureRecognizer_DestroyQGestureRecognizer(this); };
};

Q_DECLARE_METATYPE(QGestureRecognizer*)
Q_DECLARE_METATYPE(MyQGestureRecognizer*)

int QGestureRecognizer_QGestureRecognizer_QRegisterMetaType(){qRegisterMetaType<QGestureRecognizer*>(); return qRegisterMetaType<MyQGestureRecognizer*>();}

void* QGestureRecognizer_NewQGestureRecognizer()
{
	return new MyQGestureRecognizer();
}

void* QGestureRecognizer_Create(void* ptr, void* target)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(target))) {
		return static_cast<QGestureRecognizer*>(ptr)->create(static_cast<QGraphicsObject*>(target));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(target))) {
		return static_cast<QGestureRecognizer*>(ptr)->create(static_cast<QGraphicsWidget*>(target));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(target))) {
		return static_cast<QGestureRecognizer*>(ptr)->create(static_cast<QLayout*>(target));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(target))) {
		return static_cast<QGestureRecognizer*>(ptr)->create(static_cast<QWidget*>(target));
	} else {
		return static_cast<QGestureRecognizer*>(ptr)->create(static_cast<QObject*>(target));
	}
}

void* QGestureRecognizer_CreateDefault(void* ptr, void* target)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(target))) {
		return static_cast<QGestureRecognizer*>(ptr)->QGestureRecognizer::create(static_cast<QGraphicsObject*>(target));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(target))) {
		return static_cast<QGestureRecognizer*>(ptr)->QGestureRecognizer::create(static_cast<QGraphicsWidget*>(target));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(target))) {
		return static_cast<QGestureRecognizer*>(ptr)->QGestureRecognizer::create(static_cast<QLayout*>(target));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(target))) {
		return static_cast<QGestureRecognizer*>(ptr)->QGestureRecognizer::create(static_cast<QWidget*>(target));
	} else {
		return static_cast<QGestureRecognizer*>(ptr)->QGestureRecognizer::create(static_cast<QObject*>(target));
	}
}

long long QGestureRecognizer_Recognize(void* ptr, void* gesture, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QGestureRecognizer*>(ptr)->recognize(static_cast<QGesture*>(gesture), static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QGestureRecognizer*>(ptr)->recognize(static_cast<QGesture*>(gesture), static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QGestureRecognizer*>(ptr)->recognize(static_cast<QGesture*>(gesture), static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QGestureRecognizer*>(ptr)->recognize(static_cast<QGesture*>(gesture), static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QGestureRecognizer*>(ptr)->recognize(static_cast<QGesture*>(gesture), static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

long long QGestureRecognizer_QGestureRecognizer_RegisterRecognizer(void* recognizer)
{
	return QGestureRecognizer::registerRecognizer(static_cast<QGestureRecognizer*>(recognizer));
}

void QGestureRecognizer_Reset(void* ptr, void* gesture)
{
	static_cast<QGestureRecognizer*>(ptr)->reset(static_cast<QGesture*>(gesture));
}

void QGestureRecognizer_ResetDefault(void* ptr, void* gesture)
{
		static_cast<QGestureRecognizer*>(ptr)->QGestureRecognizer::reset(static_cast<QGesture*>(gesture));
}

void QGestureRecognizer_QGestureRecognizer_UnregisterRecognizer(long long ty)
{
	QGestureRecognizer::unregisterRecognizer(static_cast<Qt::GestureType>(ty));
}

void QGestureRecognizer_DestroyQGestureRecognizer(void* ptr)
{
	static_cast<QGestureRecognizer*>(ptr)->~QGestureRecognizer();
}

void QGestureRecognizer_DestroyQGestureRecognizerDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsAnchor: public QGraphicsAnchor
{
public:
	 ~MyQGraphicsAnchor() { callbackQGraphicsAnchor_DestroyQGraphicsAnchor(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsAnchor_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsAnchor_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsAnchor_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsAnchor_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsAnchor_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsAnchor_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsAnchor_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsAnchor_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsAnchor_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsAnchor_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsAnchor_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsAnchor*)
Q_DECLARE_METATYPE(MyQGraphicsAnchor*)

int QGraphicsAnchor_QGraphicsAnchor_QRegisterMetaType(){qRegisterMetaType<QGraphicsAnchor*>(); return qRegisterMetaType<MyQGraphicsAnchor*>();}

void QGraphicsAnchor_SetSizePolicy(void* ptr, long long policy)
{
	static_cast<QGraphicsAnchor*>(ptr)->setSizePolicy(static_cast<QSizePolicy::Policy>(policy));
}

void QGraphicsAnchor_SetSpacing(void* ptr, double spacing)
{
	static_cast<QGraphicsAnchor*>(ptr)->setSpacing(spacing);
}

long long QGraphicsAnchor_SizePolicy(void* ptr)
{
	return static_cast<QGraphicsAnchor*>(ptr)->sizePolicy();
}

double QGraphicsAnchor_Spacing(void* ptr)
{
	return static_cast<QGraphicsAnchor*>(ptr)->spacing();
}

void QGraphicsAnchor_UnsetSpacing(void* ptr)
{
	static_cast<QGraphicsAnchor*>(ptr)->unsetSpacing();
}

void QGraphicsAnchor_DestroyQGraphicsAnchor(void* ptr)
{
	static_cast<QGraphicsAnchor*>(ptr)->~QGraphicsAnchor();
}

void QGraphicsAnchor_DestroyQGraphicsAnchorDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QGraphicsAnchor___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsAnchor___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QGraphicsAnchor___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QGraphicsAnchor___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsAnchor___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QGraphicsAnchor___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsAnchor___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

void QGraphicsAnchor_DeleteLaterDefault(void* ptr)
{
		static_cast<QGraphicsAnchor*>(ptr)->QGraphicsAnchor::deleteLater();
}

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

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

char QGraphicsAnchor_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsAnchor*>(ptr)->QGraphicsAnchor::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsAnchor*>(ptr)->QGraphicsAnchor::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsAnchor*>(ptr)->QGraphicsAnchor::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsAnchor*>(ptr)->QGraphicsAnchor::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QGraphicsAnchor*>(ptr)->QGraphicsAnchor::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQGraphicsAnchorLayout: public QGraphicsAnchorLayout
{
public:
	MyQGraphicsAnchorLayout(QGraphicsLayoutItem *parent = Q_NULLPTR) : QGraphicsAnchorLayout(parent) {QGraphicsAnchorLayout_QGraphicsAnchorLayout_QRegisterMetaType();};
	int count() const { return callbackQGraphicsAnchorLayout_Count(const_cast<void*>(static_cast<const void*>(this))); };
	void invalidate() { callbackQGraphicsLayout_Invalidate(this); };
	QGraphicsLayoutItem * itemAt(int index) const { return static_cast<QGraphicsLayoutItem*>(callbackQGraphicsAnchorLayout_ItemAt(const_cast<void*>(static_cast<const void*>(this)), index)); };
	void removeAt(int index) { callbackQGraphicsAnchorLayout_RemoveAt(this, index); };
	void setGeometry(const QRectF & geom) { callbackQGraphicsLayoutItem_SetGeometry(this, const_cast<QRectF*>(&geom)); };
	QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsAnchorLayout_SizeHint(const_cast<void*>(static_cast<const void*>(this)), which, const_cast<QSizeF*>(&constraint))); };
	 ~MyQGraphicsAnchorLayout() { callbackQGraphicsAnchorLayout_DestroyQGraphicsAnchorLayout(this); };
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsLayoutItem_GetContentsMargins(const_cast<void*>(static_cast<const void*>(this)), *left, *top, *right, *bottom); };
	void updateGeometry() { callbackQGraphicsLayoutItem_UpdateGeometry(this); };
	void widgetEvent(QEvent * e) { callbackQGraphicsLayout_WidgetEvent(this, e); };
};

Q_DECLARE_METATYPE(QGraphicsAnchorLayout*)
Q_DECLARE_METATYPE(MyQGraphicsAnchorLayout*)

int QGraphicsAnchorLayout_QGraphicsAnchorLayout_QRegisterMetaType(){qRegisterMetaType<QGraphicsAnchorLayout*>(); return qRegisterMetaType<MyQGraphicsAnchorLayout*>();}

void* QGraphicsAnchorLayout_NewQGraphicsAnchorLayout(void* parent)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsAnchorLayout(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsAnchorLayout(static_cast<QGraphicsLayoutItem*>(parent));
	}
}

void* QGraphicsAnchorLayout_AddAnchor(void* ptr, void* firstItem, long long firstEdge, void* secondItem, long long secondEdge)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(firstItem))) {
		return static_cast<QGraphicsAnchorLayout*>(ptr)->addAnchor(static_cast<QGraphicsWidget*>(firstItem), static_cast<Qt::AnchorPoint>(firstEdge), static_cast<QGraphicsLayoutItem*>(secondItem), static_cast<Qt::AnchorPoint>(secondEdge));
	} else {
		return static_cast<QGraphicsAnchorLayout*>(ptr)->addAnchor(static_cast<QGraphicsLayoutItem*>(firstItem), static_cast<Qt::AnchorPoint>(firstEdge), static_cast<QGraphicsLayoutItem*>(secondItem), static_cast<Qt::AnchorPoint>(secondEdge));
	}
}

void QGraphicsAnchorLayout_AddAnchors(void* ptr, void* firstItem, void* secondItem, long long orientations)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(firstItem))) {
		static_cast<QGraphicsAnchorLayout*>(ptr)->addAnchors(static_cast<QGraphicsWidget*>(firstItem), static_cast<QGraphicsLayoutItem*>(secondItem), static_cast<Qt::Orientation>(orientations));
	} else {
		static_cast<QGraphicsAnchorLayout*>(ptr)->addAnchors(static_cast<QGraphicsLayoutItem*>(firstItem), static_cast<QGraphicsLayoutItem*>(secondItem), static_cast<Qt::Orientation>(orientations));
	}
}

void QGraphicsAnchorLayout_AddCornerAnchors(void* ptr, void* firstItem, long long firstCorner, void* secondItem, long long secondCorner)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(firstItem))) {
		static_cast<QGraphicsAnchorLayout*>(ptr)->addCornerAnchors(static_cast<QGraphicsWidget*>(firstItem), static_cast<Qt::Corner>(firstCorner), static_cast<QGraphicsLayoutItem*>(secondItem), static_cast<Qt::Corner>(secondCorner));
	} else {
		static_cast<QGraphicsAnchorLayout*>(ptr)->addCornerAnchors(static_cast<QGraphicsLayoutItem*>(firstItem), static_cast<Qt::Corner>(firstCorner), static_cast<QGraphicsLayoutItem*>(secondItem), static_cast<Qt::Corner>(secondCorner));
	}
}

void* QGraphicsAnchorLayout_Anchor(void* ptr, void* firstItem, long long firstEdge, void* secondItem, long long secondEdge)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(firstItem))) {
		return static_cast<QGraphicsAnchorLayout*>(ptr)->anchor(static_cast<QGraphicsWidget*>(firstItem), static_cast<Qt::AnchorPoint>(firstEdge), static_cast<QGraphicsLayoutItem*>(secondItem), static_cast<Qt::AnchorPoint>(secondEdge));
	} else {
		return static_cast<QGraphicsAnchorLayout*>(ptr)->anchor(static_cast<QGraphicsLayoutItem*>(firstItem), static_cast<Qt::AnchorPoint>(firstEdge), static_cast<QGraphicsLayoutItem*>(secondItem), static_cast<Qt::AnchorPoint>(secondEdge));
	}
}

int QGraphicsAnchorLayout_Count(void* ptr)
{
	return static_cast<QGraphicsAnchorLayout*>(ptr)->count();
}

int QGraphicsAnchorLayout_CountDefault(void* ptr)
{
		return static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::count();
}

double QGraphicsAnchorLayout_HorizontalSpacing(void* ptr)
{
	return static_cast<QGraphicsAnchorLayout*>(ptr)->horizontalSpacing();
}

void* QGraphicsAnchorLayout_ItemAt(void* ptr, int index)
{
	return static_cast<QGraphicsAnchorLayout*>(ptr)->itemAt(index);
}

void* QGraphicsAnchorLayout_ItemAtDefault(void* ptr, int index)
{
		return static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::itemAt(index);
}

void QGraphicsAnchorLayout_RemoveAt(void* ptr, int index)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->removeAt(index);
}

void QGraphicsAnchorLayout_RemoveAtDefault(void* ptr, int index)
{
		static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::removeAt(index);
}

void QGraphicsAnchorLayout_SetHorizontalSpacing(void* ptr, double spacing)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->setHorizontalSpacing(spacing);
}

void QGraphicsAnchorLayout_SetSpacing(void* ptr, double spacing)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->setSpacing(spacing);
}

void QGraphicsAnchorLayout_SetVerticalSpacing(void* ptr, double spacing)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->setVerticalSpacing(spacing);
}

void* QGraphicsAnchorLayout_SizeHint(void* ptr, long long which, void* constraint)
{
	return ({ QSizeF tmpValue = static_cast<QGraphicsAnchorLayout*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsAnchorLayout_SizeHintDefault(void* ptr, long long which, void* constraint)
{
		return ({ QSizeF tmpValue = static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

double QGraphicsAnchorLayout_VerticalSpacing(void* ptr)
{
	return static_cast<QGraphicsAnchorLayout*>(ptr)->verticalSpacing();
}

void QGraphicsAnchorLayout_DestroyQGraphicsAnchorLayout(void* ptr)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->~QGraphicsAnchorLayout();
}

void QGraphicsAnchorLayout_DestroyQGraphicsAnchorLayoutDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsBlurEffect: public QGraphicsBlurEffect
{
public:
	MyQGraphicsBlurEffect(QObject *parent = Q_NULLPTR) : QGraphicsBlurEffect(parent) {QGraphicsBlurEffect_QGraphicsBlurEffect_QRegisterMetaType();};
	void Signal_BlurHintsChanged(QGraphicsBlurEffect::BlurHints hints) { callbackQGraphicsBlurEffect_BlurHintsChanged(this, hints); };
	void Signal_BlurRadiusChanged(qreal radius) { callbackQGraphicsBlurEffect_BlurRadiusChanged(this, radius); };
	QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsEffect_BoundingRectFor(const_cast<void*>(static_cast<const void*>(this)), const_cast<QRectF*>(&rect))); };
	void draw(QPainter * painter) { callbackQGraphicsBlurEffect_Draw(this, painter); };
	void setBlurHints(QGraphicsBlurEffect::BlurHints hints) { callbackQGraphicsBlurEffect_SetBlurHints(this, hints); };
	void setBlurRadius(qreal blurRadius) { callbackQGraphicsBlurEffect_SetBlurRadius(this, blurRadius); };
	 ~MyQGraphicsBlurEffect() { callbackQGraphicsBlurEffect_DestroyQGraphicsBlurEffect(this); };
	void Signal_EnabledChanged(bool enabled) { callbackQGraphicsEffect_EnabledChanged(this, enabled); };
	void setEnabled(bool enable) { callbackQGraphicsEffect_SetEnabled(this, enable); };
	void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsEffect_SourceChanged(this, flags); };
	void update() { callbackQGraphicsEffect_Update(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsEffect_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsEffect_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsEffect_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsEffect_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsEffect_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsEffect_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsEffect_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsEffect_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsEffect_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsEffect_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsEffect_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsBlurEffect*)
Q_DECLARE_METATYPE(MyQGraphicsBlurEffect*)

int QGraphicsBlurEffect_QGraphicsBlurEffect_QRegisterMetaType(){qRegisterMetaType<QGraphicsBlurEffect*>(); return qRegisterMetaType<MyQGraphicsBlurEffect*>();}

void* QGraphicsBlurEffect_NewQGraphicsBlurEffect(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsBlurEffect(static_cast<QWindow*>(parent));
	} else {
		return new MyQGraphicsBlurEffect(static_cast<QObject*>(parent));
	}
}

long long QGraphicsBlurEffect_BlurHints(void* ptr)
{
	return static_cast<QGraphicsBlurEffect*>(ptr)->blurHints();
}

void QGraphicsBlurEffect_ConnectBlurHintsChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsBlurEffect*>(ptr), static_cast<void (QGraphicsBlurEffect::*)(QGraphicsBlurEffect::BlurHints)>(&QGraphicsBlurEffect::blurHintsChanged), static_cast<MyQGraphicsBlurEffect*>(ptr), static_cast<void (MyQGraphicsBlurEffect::*)(QGraphicsBlurEffect::BlurHints)>(&MyQGraphicsBlurEffect::Signal_BlurHintsChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsBlurEffect_DisconnectBlurHintsChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsBlurEffect*>(ptr), static_cast<void (QGraphicsBlurEffect::*)(QGraphicsBlurEffect::BlurHints)>(&QGraphicsBlurEffect::blurHintsChanged), static_cast<MyQGraphicsBlurEffect*>(ptr), static_cast<void (MyQGraphicsBlurEffect::*)(QGraphicsBlurEffect::BlurHints)>(&MyQGraphicsBlurEffect::Signal_BlurHintsChanged));
}

void QGraphicsBlurEffect_BlurHintsChanged(void* ptr, long long hints)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->blurHintsChanged(static_cast<QGraphicsBlurEffect::BlurHint>(hints));
}

double QGraphicsBlurEffect_BlurRadius(void* ptr)
{
	return static_cast<QGraphicsBlurEffect*>(ptr)->blurRadius();
}

void QGraphicsBlurEffect_ConnectBlurRadiusChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsBlurEffect*>(ptr), static_cast<void (QGraphicsBlurEffect::*)(qreal)>(&QGraphicsBlurEffect::blurRadiusChanged), static_cast<MyQGraphicsBlurEffect*>(ptr), static_cast<void (MyQGraphicsBlurEffect::*)(qreal)>(&MyQGraphicsBlurEffect::Signal_BlurRadiusChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsBlurEffect_DisconnectBlurRadiusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsBlurEffect*>(ptr), static_cast<void (QGraphicsBlurEffect::*)(qreal)>(&QGraphicsBlurEffect::blurRadiusChanged), static_cast<MyQGraphicsBlurEffect*>(ptr), static_cast<void (MyQGraphicsBlurEffect::*)(qreal)>(&MyQGraphicsBlurEffect::Signal_BlurRadiusChanged));
}

void QGraphicsBlurEffect_BlurRadiusChanged(void* ptr, double radius)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->blurRadiusChanged(radius);
}

void QGraphicsBlurEffect_Draw(void* ptr, void* painter)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->draw(static_cast<QPainter*>(painter));
}

void QGraphicsBlurEffect_DrawDefault(void* ptr, void* painter)
{
		static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::draw(static_cast<QPainter*>(painter));
}

void QGraphicsBlurEffect_SetBlurHints(void* ptr, long long hints)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsBlurEffect*>(ptr), "setBlurHints", Q_ARG(QGraphicsBlurEffect::BlurHints, static_cast<QGraphicsBlurEffect::BlurHint>(hints)));
}

void QGraphicsBlurEffect_SetBlurHintsDefault(void* ptr, long long hints)
{
		static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::setBlurHints(static_cast<QGraphicsBlurEffect::BlurHint>(hints));
}

void QGraphicsBlurEffect_SetBlurRadius(void* ptr, double blurRadius)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsBlurEffect*>(ptr), "setBlurRadius", Q_ARG(qreal, blurRadius));
}

void QGraphicsBlurEffect_SetBlurRadiusDefault(void* ptr, double blurRadius)
{
		static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::setBlurRadius(blurRadius);
}

void QGraphicsBlurEffect_DestroyQGraphicsBlurEffect(void* ptr)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->~QGraphicsBlurEffect();
}

void QGraphicsBlurEffect_DestroyQGraphicsBlurEffectDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsColorizeEffect: public QGraphicsColorizeEffect
{
public:
	MyQGraphicsColorizeEffect(QObject *parent = Q_NULLPTR) : QGraphicsColorizeEffect(parent) {QGraphicsColorizeEffect_QGraphicsColorizeEffect_QRegisterMetaType();};
	void Signal_ColorChanged(const QColor & color) { callbackQGraphicsColorizeEffect_ColorChanged(this, const_cast<QColor*>(&color)); };
	void draw(QPainter * painter) { callbackQGraphicsColorizeEffect_Draw(this, painter); };
	void setColor(const QColor & c) { callbackQGraphicsColorizeEffect_SetColor(this, const_cast<QColor*>(&c)); };
	void setStrength(qreal strength) { callbackQGraphicsColorizeEffect_SetStrength(this, strength); };
	void Signal_StrengthChanged(qreal strength) { callbackQGraphicsColorizeEffect_StrengthChanged(this, strength); };
	 ~MyQGraphicsColorizeEffect() { callbackQGraphicsColorizeEffect_DestroyQGraphicsColorizeEffect(this); };
	QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsEffect_BoundingRectFor(const_cast<void*>(static_cast<const void*>(this)), const_cast<QRectF*>(&rect))); };
	void Signal_EnabledChanged(bool enabled) { callbackQGraphicsEffect_EnabledChanged(this, enabled); };
	void setEnabled(bool enable) { callbackQGraphicsEffect_SetEnabled(this, enable); };
	void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsEffect_SourceChanged(this, flags); };
	void update() { callbackQGraphicsEffect_Update(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsEffect_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsEffect_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsEffect_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsEffect_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsEffect_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsEffect_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsEffect_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsEffect_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsEffect_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsEffect_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsEffect_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsColorizeEffect*)
Q_DECLARE_METATYPE(MyQGraphicsColorizeEffect*)

int QGraphicsColorizeEffect_QGraphicsColorizeEffect_QRegisterMetaType(){qRegisterMetaType<QGraphicsColorizeEffect*>(); return qRegisterMetaType<MyQGraphicsColorizeEffect*>();}

void* QGraphicsColorizeEffect_NewQGraphicsColorizeEffect(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsColorizeEffect(static_cast<QWindow*>(parent));
	} else {
		return new MyQGraphicsColorizeEffect(static_cast<QObject*>(parent));
	}
}

void* QGraphicsColorizeEffect_Color(void* ptr)
{
	return new QColor(static_cast<QGraphicsColorizeEffect*>(ptr)->color());
}

void QGraphicsColorizeEffect_ConnectColorChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsColorizeEffect*>(ptr), static_cast<void (QGraphicsColorizeEffect::*)(const QColor &)>(&QGraphicsColorizeEffect::colorChanged), static_cast<MyQGraphicsColorizeEffect*>(ptr), static_cast<void (MyQGraphicsColorizeEffect::*)(const QColor &)>(&MyQGraphicsColorizeEffect::Signal_ColorChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsColorizeEffect_DisconnectColorChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsColorizeEffect*>(ptr), static_cast<void (QGraphicsColorizeEffect::*)(const QColor &)>(&QGraphicsColorizeEffect::colorChanged), static_cast<MyQGraphicsColorizeEffect*>(ptr), static_cast<void (MyQGraphicsColorizeEffect::*)(const QColor &)>(&MyQGraphicsColorizeEffect::Signal_ColorChanged));
}

void QGraphicsColorizeEffect_ColorChanged(void* ptr, void* color)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->colorChanged(*static_cast<QColor*>(color));
}

void QGraphicsColorizeEffect_Draw(void* ptr, void* painter)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->draw(static_cast<QPainter*>(painter));
}

void QGraphicsColorizeEffect_DrawDefault(void* ptr, void* painter)
{
		static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::draw(static_cast<QPainter*>(painter));
}

void QGraphicsColorizeEffect_SetColor(void* ptr, void* c)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsColorizeEffect*>(ptr), "setColor", Q_ARG(const QColor, *static_cast<QColor*>(c)));
}

void QGraphicsColorizeEffect_SetColorDefault(void* ptr, void* c)
{
		static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::setColor(*static_cast<QColor*>(c));
}

void QGraphicsColorizeEffect_SetStrength(void* ptr, double strength)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsColorizeEffect*>(ptr), "setStrength", Q_ARG(qreal, strength));
}

void QGraphicsColorizeEffect_SetStrengthDefault(void* ptr, double strength)
{
		static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::setStrength(strength);
}

double QGraphicsColorizeEffect_Strength(void* ptr)
{
	return static_cast<QGraphicsColorizeEffect*>(ptr)->strength();
}

void QGraphicsColorizeEffect_ConnectStrengthChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsColorizeEffect*>(ptr), static_cast<void (QGraphicsColorizeEffect::*)(qreal)>(&QGraphicsColorizeEffect::strengthChanged), static_cast<MyQGraphicsColorizeEffect*>(ptr), static_cast<void (MyQGraphicsColorizeEffect::*)(qreal)>(&MyQGraphicsColorizeEffect::Signal_StrengthChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsColorizeEffect_DisconnectStrengthChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsColorizeEffect*>(ptr), static_cast<void (QGraphicsColorizeEffect::*)(qreal)>(&QGraphicsColorizeEffect::strengthChanged), static_cast<MyQGraphicsColorizeEffect*>(ptr), static_cast<void (MyQGraphicsColorizeEffect::*)(qreal)>(&MyQGraphicsColorizeEffect::Signal_StrengthChanged));
}

void QGraphicsColorizeEffect_StrengthChanged(void* ptr, double strength)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->strengthChanged(strength);
}

void QGraphicsColorizeEffect_DestroyQGraphicsColorizeEffect(void* ptr)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->~QGraphicsColorizeEffect();
}

void QGraphicsColorizeEffect_DestroyQGraphicsColorizeEffectDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsDropShadowEffect: public QGraphicsDropShadowEffect
{
public:
	MyQGraphicsDropShadowEffect(QObject *parent = Q_NULLPTR) : QGraphicsDropShadowEffect(parent) {QGraphicsDropShadowEffect_QGraphicsDropShadowEffect_QRegisterMetaType();};
	void Signal_BlurRadiusChanged(qreal blurRadius) { callbackQGraphicsDropShadowEffect_BlurRadiusChanged(this, blurRadius); };
	QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsEffect_BoundingRectFor(const_cast<void*>(static_cast<const void*>(this)), const_cast<QRectF*>(&rect))); };
	void Signal_ColorChanged(const QColor & color) { callbackQGraphicsDropShadowEffect_ColorChanged(this, const_cast<QColor*>(&color)); };
	void draw(QPainter * painter) { callbackQGraphicsDropShadowEffect_Draw(this, painter); };
	void Signal_OffsetChanged(const QPointF & offset) { callbackQGraphicsDropShadowEffect_OffsetChanged(this, const_cast<QPointF*>(&offset)); };
	void setBlurRadius(qreal blurRadius) { callbackQGraphicsDropShadowEffect_SetBlurRadius(this, blurRadius); };
	void setColor(const QColor & color) { callbackQGraphicsDropShadowEffect_SetColor(this, const_cast<QColor*>(&color)); };
	void setOffset(const QPointF & ofs) { callbackQGraphicsDropShadowEffect_SetOffset(this, const_cast<QPointF*>(&ofs)); };
	void setOffset(qreal dx, qreal dy) { callbackQGraphicsDropShadowEffect_SetOffset2(this, dx, dy); };
	void setOffset(qreal d) { callbackQGraphicsDropShadowEffect_SetOffset3(this, d); };
	void setXOffset(qreal dx) { callbackQGraphicsDropShadowEffect_SetXOffset(this, dx); };
	void setYOffset(qreal dy) { callbackQGraphicsDropShadowEffect_SetYOffset(this, dy); };
	 ~MyQGraphicsDropShadowEffect() { callbackQGraphicsDropShadowEffect_DestroyQGraphicsDropShadowEffect(this); };
	void Signal_EnabledChanged(bool enabled) { callbackQGraphicsEffect_EnabledChanged(this, enabled); };
	void setEnabled(bool enable) { callbackQGraphicsEffect_SetEnabled(this, enable); };
	void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsEffect_SourceChanged(this, flags); };
	void update() { callbackQGraphicsEffect_Update(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsEffect_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsEffect_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsEffect_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsEffect_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsEffect_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsEffect_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsEffect_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsEffect_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsEffect_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsEffect_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsEffect_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsDropShadowEffect*)
Q_DECLARE_METATYPE(MyQGraphicsDropShadowEffect*)

int QGraphicsDropShadowEffect_QGraphicsDropShadowEffect_QRegisterMetaType(){qRegisterMetaType<QGraphicsDropShadowEffect*>(); return qRegisterMetaType<MyQGraphicsDropShadowEffect*>();}

void* QGraphicsDropShadowEffect_NewQGraphicsDropShadowEffect(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsDropShadowEffect(static_cast<QWindow*>(parent));
	} else {
		return new MyQGraphicsDropShadowEffect(static_cast<QObject*>(parent));
	}
}

double QGraphicsDropShadowEffect_BlurRadius(void* ptr)
{
	return static_cast<QGraphicsDropShadowEffect*>(ptr)->blurRadius();
}

void QGraphicsDropShadowEffect_ConnectBlurRadiusChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsDropShadowEffect*>(ptr), static_cast<void (QGraphicsDropShadowEffect::*)(qreal)>(&QGraphicsDropShadowEffect::blurRadiusChanged), static_cast<MyQGraphicsDropShadowEffect*>(ptr), static_cast<void (MyQGraphicsDropShadowEffect::*)(qreal)>(&MyQGraphicsDropShadowEffect::Signal_BlurRadiusChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsDropShadowEffect_DisconnectBlurRadiusChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsDropShadowEffect*>(ptr), static_cast<void (QGraphicsDropShadowEffect::*)(qreal)>(&QGraphicsDropShadowEffect::blurRadiusChanged), static_cast<MyQGraphicsDropShadowEffect*>(ptr), static_cast<void (MyQGraphicsDropShadowEffect::*)(qreal)>(&MyQGraphicsDropShadowEffect::Signal_BlurRadiusChanged));
}

void QGraphicsDropShadowEffect_BlurRadiusChanged(void* ptr, double blurRadius)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->blurRadiusChanged(blurRadius);
}

void* QGraphicsDropShadowEffect_Color(void* ptr)
{
	return new QColor(static_cast<QGraphicsDropShadowEffect*>(ptr)->color());
}

void QGraphicsDropShadowEffect_ConnectColorChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsDropShadowEffect*>(ptr), static_cast<void (QGraphicsDropShadowEffect::*)(const QColor &)>(&QGraphicsDropShadowEffect::colorChanged), static_cast<MyQGraphicsDropShadowEffect*>(ptr), static_cast<void (MyQGraphicsDropShadowEffect::*)(const QColor &)>(&MyQGraphicsDropShadowEffect::Signal_ColorChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsDropShadowEffect_DisconnectColorChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsDropShadowEffect*>(ptr), static_cast<void (QGraphicsDropShadowEffect::*)(const QColor &)>(&QGraphicsDropShadowEffect::colorChanged), static_cast<MyQGraphicsDropShadowEffect*>(ptr), static_cast<void (MyQGraphicsDropShadowEffect::*)(const QColor &)>(&MyQGraphicsDropShadowEffect::Signal_ColorChanged));
}

void QGraphicsDropShadowEffect_ColorChanged(void* ptr, void* color)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->colorChanged(*static_cast<QColor*>(color));
}

void QGraphicsDropShadowEffect_Draw(void* ptr, void* painter)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->draw(static_cast<QPainter*>(painter));
}

void QGraphicsDropShadowEffect_DrawDefault(void* ptr, void* painter)
{
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::draw(static_cast<QPainter*>(painter));
}

void* QGraphicsDropShadowEffect_Offset(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsDropShadowEffect*>(ptr)->offset(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QGraphicsDropShadowEffect_ConnectOffsetChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsDropShadowEffect*>(ptr), static_cast<void (QGraphicsDropShadowEffect::*)(const QPointF &)>(&QGraphicsDropShadowEffect::offsetChanged), static_cast<MyQGraphicsDropShadowEffect*>(ptr), static_cast<void (MyQGraphicsDropShadowEffect::*)(const QPointF &)>(&MyQGraphicsDropShadowEffect::Signal_OffsetChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsDropShadowEffect_DisconnectOffsetChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsDropShadowEffect*>(ptr), static_cast<void (QGraphicsDropShadowEffect::*)(const QPointF &)>(&QGraphicsDropShadowEffect::offsetChanged), static_cast<MyQGraphicsDropShadowEffect*>(ptr), static_cast<void (MyQGraphicsDropShadowEffect::*)(const QPointF &)>(&MyQGraphicsDropShadowEffect::Signal_OffsetChanged));
}

void QGraphicsDropShadowEffect_OffsetChanged(void* ptr, void* offset)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->offsetChanged(*static_cast<QPointF*>(offset));
}

void QGraphicsDropShadowEffect_SetBlurRadius(void* ptr, double blurRadius)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setBlurRadius", Q_ARG(qreal, blurRadius));
}

void QGraphicsDropShadowEffect_SetBlurRadiusDefault(void* ptr, double blurRadius)
{
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::setBlurRadius(blurRadius);
}

void QGraphicsDropShadowEffect_SetColor(void* ptr, void* color)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setColor", Q_ARG(const QColor, *static_cast<QColor*>(color)));
}

void QGraphicsDropShadowEffect_SetColorDefault(void* ptr, void* color)
{
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::setColor(*static_cast<QColor*>(color));
}

void QGraphicsDropShadowEffect_SetOffset(void* ptr, void* ofs)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setOffset", Q_ARG(const QPointF, *static_cast<QPointF*>(ofs)));
}

void QGraphicsDropShadowEffect_SetOffsetDefault(void* ptr, void* ofs)
{
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::setOffset(*static_cast<QPointF*>(ofs));
}

void QGraphicsDropShadowEffect_SetOffset2(void* ptr, double dx, double dy)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setOffset", Q_ARG(qreal, dx), Q_ARG(qreal, dy));
}

void QGraphicsDropShadowEffect_SetOffset2Default(void* ptr, double dx, double dy)
{
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::setOffset(dx, dy);
}

void QGraphicsDropShadowEffect_SetOffset3(void* ptr, double d)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setOffset", Q_ARG(qreal, d));
}

void QGraphicsDropShadowEffect_SetOffset3Default(void* ptr, double d)
{
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::setOffset(d);
}

void QGraphicsDropShadowEffect_SetXOffset(void* ptr, double dx)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setXOffset", Q_ARG(qreal, dx));
}

void QGraphicsDropShadowEffect_SetXOffsetDefault(void* ptr, double dx)
{
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::setXOffset(dx);
}

void QGraphicsDropShadowEffect_SetYOffset(void* ptr, double dy)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setYOffset", Q_ARG(qreal, dy));
}

void QGraphicsDropShadowEffect_SetYOffsetDefault(void* ptr, double dy)
{
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::setYOffset(dy);
}

double QGraphicsDropShadowEffect_XOffset(void* ptr)
{
	return static_cast<QGraphicsDropShadowEffect*>(ptr)->xOffset();
}

double QGraphicsDropShadowEffect_YOffset(void* ptr)
{
	return static_cast<QGraphicsDropShadowEffect*>(ptr)->yOffset();
}

void QGraphicsDropShadowEffect_DestroyQGraphicsDropShadowEffect(void* ptr)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->~QGraphicsDropShadowEffect();
}

void QGraphicsDropShadowEffect_DestroyQGraphicsDropShadowEffectDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsEffect: public QGraphicsEffect
{
public:
	MyQGraphicsEffect(QObject *parent = Q_NULLPTR) : QGraphicsEffect(parent) {QGraphicsEffect_QGraphicsEffect_QRegisterMetaType();};
	QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsEffect_BoundingRectFor(const_cast<void*>(static_cast<const void*>(this)), const_cast<QRectF*>(&rect))); };
	void draw(QPainter * painter) { callbackQGraphicsEffect_Draw(this, painter); };
	void Signal_EnabledChanged(bool enabled) { callbackQGraphicsEffect_EnabledChanged(this, enabled); };
	void setEnabled(bool enable) { callbackQGraphicsEffect_SetEnabled(this, enable); };
	void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsEffect_SourceChanged(this, flags); };
	void update() { callbackQGraphicsEffect_Update(this); };
	 ~MyQGraphicsEffect() { callbackQGraphicsEffect_DestroyQGraphicsEffect(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsEffect_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsEffect_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsEffect_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsEffect_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsEffect_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsEffect_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsEffect_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsEffect_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsEffect_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsEffect_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsEffect_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsEffect*)
Q_DECLARE_METATYPE(MyQGraphicsEffect*)

int QGraphicsEffect_QGraphicsEffect_QRegisterMetaType(){qRegisterMetaType<QGraphicsEffect*>(); return qRegisterMetaType<MyQGraphicsEffect*>();}

void* QGraphicsEffect_NewQGraphicsEffect(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEffect(static_cast<QWindow*>(parent));
	} else {
		return new MyQGraphicsEffect(static_cast<QObject*>(parent));
	}
}

void* QGraphicsEffect_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsEffect*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsEffect_BoundingRectFor(void* ptr, void* rect)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsEffect_BoundingRectForDefault(void* ptr, void* rect)
{
	if (dynamic_cast<QGraphicsOpacityEffect*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsDropShadowEffect*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsBlurEffect*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsColorizeEffect*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void QGraphicsEffect_Draw(void* ptr, void* painter)
{
	static_cast<QGraphicsEffect*>(ptr)->draw(static_cast<QPainter*>(painter));
}

void QGraphicsEffect_DrawSource(void* ptr, void* painter)
{
	static_cast<QGraphicsEffect*>(ptr)->drawSource(static_cast<QPainter*>(painter));
}

void QGraphicsEffect_ConnectEnabledChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsEffect*>(ptr), static_cast<void (QGraphicsEffect::*)(bool)>(&QGraphicsEffect::enabledChanged), static_cast<MyQGraphicsEffect*>(ptr), static_cast<void (MyQGraphicsEffect::*)(bool)>(&MyQGraphicsEffect::Signal_EnabledChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsEffect_DisconnectEnabledChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsEffect*>(ptr), static_cast<void (QGraphicsEffect::*)(bool)>(&QGraphicsEffect::enabledChanged), static_cast<MyQGraphicsEffect*>(ptr), static_cast<void (MyQGraphicsEffect::*)(bool)>(&MyQGraphicsEffect::Signal_EnabledChanged));
}

void QGraphicsEffect_EnabledChanged(void* ptr, char enabled)
{
	static_cast<QGraphicsEffect*>(ptr)->enabledChanged(enabled != 0);
}

char QGraphicsEffect_IsEnabled(void* ptr)
{
	return static_cast<QGraphicsEffect*>(ptr)->isEnabled();
}

void QGraphicsEffect_SetEnabled(void* ptr, char enable)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsEffect*>(ptr), "setEnabled", Q_ARG(bool, enable != 0));
}

void QGraphicsEffect_SetEnabledDefault(void* ptr, char enable)
{
	if (dynamic_cast<QGraphicsOpacityEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::setEnabled(enable != 0);
	} else if (dynamic_cast<QGraphicsDropShadowEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::setEnabled(enable != 0);
	} else if (dynamic_cast<QGraphicsBlurEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::setEnabled(enable != 0);
	} else if (dynamic_cast<QGraphicsColorizeEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::setEnabled(enable != 0);
	} else {
		static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::setEnabled(enable != 0);
	}
}

void* QGraphicsEffect_SourceBoundingRect(void* ptr, long long system)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsEffect*>(ptr)->sourceBoundingRect(static_cast<Qt::CoordinateSystem>(system)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsEffect_SourceChanged(void* ptr, long long flags)
{
	static_cast<QGraphicsEffect*>(ptr)->sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}

void QGraphicsEffect_SourceChangedDefault(void* ptr, long long flags)
{
	if (dynamic_cast<QGraphicsOpacityEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
	} else if (dynamic_cast<QGraphicsDropShadowEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
	} else if (dynamic_cast<QGraphicsBlurEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
	} else if (dynamic_cast<QGraphicsColorizeEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
	} else {
		static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
	}
}

char QGraphicsEffect_SourceIsPixmap(void* ptr)
{
	return static_cast<QGraphicsEffect*>(ptr)->sourceIsPixmap();
}

void* QGraphicsEffect_SourcePixmap(void* ptr, long long system, void* offset, long long mode)
{
	return new QPixmap(static_cast<QGraphicsEffect*>(ptr)->sourcePixmap(static_cast<Qt::CoordinateSystem>(system), static_cast<QPoint*>(offset), static_cast<QGraphicsEffect::PixmapPadMode>(mode)));
}

void QGraphicsEffect_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsEffect*>(ptr), "update");
}

void QGraphicsEffect_UpdateDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsOpacityEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::update();
	} else if (dynamic_cast<QGraphicsDropShadowEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::update();
	} else if (dynamic_cast<QGraphicsBlurEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::update();
	} else if (dynamic_cast<QGraphicsColorizeEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::update();
	} else {
		static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::update();
	}
}

void QGraphicsEffect_UpdateBoundingRect(void* ptr)
{
	static_cast<QGraphicsEffect*>(ptr)->updateBoundingRect();
}

void QGraphicsEffect_DestroyQGraphicsEffect(void* ptr)
{
	static_cast<QGraphicsEffect*>(ptr)->~QGraphicsEffect();
}

void QGraphicsEffect_DestroyQGraphicsEffectDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QGraphicsEffect___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsEffect___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QGraphicsEffect___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QGraphicsEffect___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsEffect___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QGraphicsEffect___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsEffect___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void QGraphicsEffect_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsOpacityEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QGraphicsDropShadowEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QGraphicsBlurEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QGraphicsColorizeEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QGraphicsEffect_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QGraphicsOpacityEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsDropShadowEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsBlurEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsColorizeEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QGraphicsEffect_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsOpacityEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsDropShadowEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsBlurEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsColorizeEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::customEvent(static_cast<QEvent*>(event));
	}
}

void QGraphicsEffect_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsOpacityEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::deleteLater();
	} else if (dynamic_cast<QGraphicsDropShadowEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::deleteLater();
	} else if (dynamic_cast<QGraphicsBlurEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::deleteLater();
	} else if (dynamic_cast<QGraphicsColorizeEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::deleteLater();
	} else {
		static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::deleteLater();
	}
}

void QGraphicsEffect_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QGraphicsOpacityEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsDropShadowEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsBlurEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsColorizeEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

char QGraphicsEffect_EventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QGraphicsOpacityEffect*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QGraphicsDropShadowEffect*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QGraphicsBlurEffect*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QGraphicsColorizeEffect*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::event(static_cast<QEvent*>(e));
	} else {
		return static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::event(static_cast<QEvent*>(e));
	}
}

char QGraphicsEffect_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsOpacityEffect*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsDropShadowEffect*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsBlurEffect*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsColorizeEffect*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void* QGraphicsEffect_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsOpacityEffect*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::metaObject());
	} else if (dynamic_cast<QGraphicsDropShadowEffect*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::metaObject());
	} else if (dynamic_cast<QGraphicsBlurEffect*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::metaObject());
	} else if (dynamic_cast<QGraphicsColorizeEffect*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::metaObject());
	}
}

void QGraphicsEffect_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsOpacityEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QGraphicsDropShadowEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QGraphicsBlurEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QGraphicsColorizeEffect*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

class MyQGraphicsEllipseItem: public QGraphicsEllipseItem
{
public:
	MyQGraphicsEllipseItem(QGraphicsItem *parent = Q_NULLPTR) : QGraphicsEllipseItem(parent) {QGraphicsEllipseItem_QGraphicsEllipseItem_QRegisterMetaType();};
	MyQGraphicsEllipseItem(const QRectF &rect, QGraphicsItem *parent = Q_NULLPTR) : QGraphicsEllipseItem(rect, parent) {QGraphicsEllipseItem_QGraphicsEllipseItem_QRegisterMetaType();};
	MyQGraphicsEllipseItem(qreal x, qreal y, qreal width, qreal height, QGraphicsItem *parent = Q_NULLPTR) : QGraphicsEllipseItem(x, y, width, height, parent) {QGraphicsEllipseItem_QGraphicsEllipseItem_QRegisterMetaType();};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsEllipseItem_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsEllipseItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	 ~MyQGraphicsEllipseItem() { callbackQGraphicsEllipseItem_DestroyQGraphicsEllipseItem(this); };
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsEllipseItem*)
Q_DECLARE_METATYPE(MyQGraphicsEllipseItem*)

int QGraphicsEllipseItem_QGraphicsEllipseItem_QRegisterMetaType(){qRegisterMetaType<QGraphicsEllipseItem*>(); return qRegisterMetaType<MyQGraphicsEllipseItem*>();}

void* QGraphicsEllipseItem_NewQGraphicsEllipseItem(void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEllipseItem(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEllipseItem(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsEllipseItem(static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsEllipseItem_NewQGraphicsEllipseItem2(void* rect, void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEllipseItem(*static_cast<QRectF*>(rect), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEllipseItem(*static_cast<QRectF*>(rect), static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsEllipseItem(*static_cast<QRectF*>(rect), static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsEllipseItem_NewQGraphicsEllipseItem3(double x, double y, double width, double height, void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEllipseItem(x, y, width, height, static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsEllipseItem(x, y, width, height, static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsEllipseItem(x, y, width, height, static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsEllipseItem_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsEllipseItem*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsEllipseItem_BoundingRectDefault(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsEllipseItem_Paint(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsEllipseItem*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsEllipseItem_PaintDefault(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void* QGraphicsEllipseItem_Rect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsEllipseItem*>(ptr)->rect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsEllipseItem_SetRect(void* ptr, void* rect)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->setRect(*static_cast<QRectF*>(rect));
}

void QGraphicsEllipseItem_SetRect2(void* ptr, double x, double y, double width, double height)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->setRect(x, y, width, height);
}

void QGraphicsEllipseItem_SetSpanAngle(void* ptr, int angle)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->setSpanAngle(angle);
}

void QGraphicsEllipseItem_SetStartAngle(void* ptr, int angle)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->setStartAngle(angle);
}

int QGraphicsEllipseItem_SpanAngle(void* ptr)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->spanAngle();
}

int QGraphicsEllipseItem_StartAngle(void* ptr)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->startAngle();
}

void QGraphicsEllipseItem_DestroyQGraphicsEllipseItem(void* ptr)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->~QGraphicsEllipseItem();
}

void QGraphicsEllipseItem_DestroyQGraphicsEllipseItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsGridLayout: public QGraphicsGridLayout
{
public:
	MyQGraphicsGridLayout(QGraphicsLayoutItem *parent = Q_NULLPTR) : QGraphicsGridLayout(parent) {QGraphicsGridLayout_QGraphicsGridLayout_QRegisterMetaType();};
	int count() const { return callbackQGraphicsGridLayout_Count(const_cast<void*>(static_cast<const void*>(this))); };
	void invalidate() { callbackQGraphicsLayout_Invalidate(this); };
	void removeAt(int index) { callbackQGraphicsGridLayout_RemoveAt(this, index); };
	void setGeometry(const QRectF & rect) { callbackQGraphicsLayoutItem_SetGeometry(this, const_cast<QRectF*>(&rect)); };
	QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsGridLayout_SizeHint(const_cast<void*>(static_cast<const void*>(this)), which, const_cast<QSizeF*>(&constraint))); };
	 ~MyQGraphicsGridLayout() { callbackQGraphicsGridLayout_DestroyQGraphicsGridLayout(this); };
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsLayoutItem_GetContentsMargins(const_cast<void*>(static_cast<const void*>(this)), *left, *top, *right, *bottom); };
	void updateGeometry() { callbackQGraphicsLayoutItem_UpdateGeometry(this); };
	void widgetEvent(QEvent * e) { callbackQGraphicsLayout_WidgetEvent(this, e); };
};

Q_DECLARE_METATYPE(QGraphicsGridLayout*)
Q_DECLARE_METATYPE(MyQGraphicsGridLayout*)

int QGraphicsGridLayout_QGraphicsGridLayout_QRegisterMetaType(){qRegisterMetaType<QGraphicsGridLayout*>(); return qRegisterMetaType<MyQGraphicsGridLayout*>();}

void* QGraphicsGridLayout_NewQGraphicsGridLayout(void* parent)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsGridLayout(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsGridLayout(static_cast<QGraphicsLayoutItem*>(parent));
	}
}

void QGraphicsGridLayout_AddItem(void* ptr, void* item, int row, int column, int rowSpan, int columnSpan, long long alignment)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsGridLayout*>(ptr)->addItem(static_cast<QGraphicsWidget*>(item), row, column, rowSpan, columnSpan, static_cast<Qt::AlignmentFlag>(alignment));
	} else {
		static_cast<QGraphicsGridLayout*>(ptr)->addItem(static_cast<QGraphicsLayoutItem*>(item), row, column, rowSpan, columnSpan, static_cast<Qt::AlignmentFlag>(alignment));
	}
}

void QGraphicsGridLayout_AddItem2(void* ptr, void* item, int row, int column, long long alignment)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsGridLayout*>(ptr)->addItem(static_cast<QGraphicsWidget*>(item), row, column, static_cast<Qt::AlignmentFlag>(alignment));
	} else {
		static_cast<QGraphicsGridLayout*>(ptr)->addItem(static_cast<QGraphicsLayoutItem*>(item), row, column, static_cast<Qt::AlignmentFlag>(alignment));
	}
}

long long QGraphicsGridLayout_Alignment(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		return static_cast<QGraphicsGridLayout*>(ptr)->alignment(static_cast<QGraphicsWidget*>(item));
	} else {
		return static_cast<QGraphicsGridLayout*>(ptr)->alignment(static_cast<QGraphicsLayoutItem*>(item));
	}
}

long long QGraphicsGridLayout_ColumnAlignment(void* ptr, int column)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->columnAlignment(column);
}

int QGraphicsGridLayout_ColumnCount(void* ptr)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->columnCount();
}

double QGraphicsGridLayout_ColumnMaximumWidth(void* ptr, int column)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->columnMaximumWidth(column);
}

double QGraphicsGridLayout_ColumnMinimumWidth(void* ptr, int column)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->columnMinimumWidth(column);
}

double QGraphicsGridLayout_ColumnPreferredWidth(void* ptr, int column)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->columnPreferredWidth(column);
}

double QGraphicsGridLayout_ColumnSpacing(void* ptr, int column)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->columnSpacing(column);
}

int QGraphicsGridLayout_ColumnStretchFactor(void* ptr, int column)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->columnStretchFactor(column);
}

int QGraphicsGridLayout_Count(void* ptr)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->count();
}

int QGraphicsGridLayout_CountDefault(void* ptr)
{
		return static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::count();
}

double QGraphicsGridLayout_HorizontalSpacing(void* ptr)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->horizontalSpacing();
}

void QGraphicsGridLayout_RemoveAt(void* ptr, int index)
{
	static_cast<QGraphicsGridLayout*>(ptr)->removeAt(index);
}

void QGraphicsGridLayout_RemoveAtDefault(void* ptr, int index)
{
		static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::removeAt(index);
}

void QGraphicsGridLayout_RemoveItem(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsGridLayout*>(ptr)->removeItem(static_cast<QGraphicsWidget*>(item));
	} else {
		static_cast<QGraphicsGridLayout*>(ptr)->removeItem(static_cast<QGraphicsLayoutItem*>(item));
	}
}

long long QGraphicsGridLayout_RowAlignment(void* ptr, int row)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->rowAlignment(row);
}

int QGraphicsGridLayout_RowCount(void* ptr)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->rowCount();
}

double QGraphicsGridLayout_RowMaximumHeight(void* ptr, int row)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->rowMaximumHeight(row);
}

double QGraphicsGridLayout_RowMinimumHeight(void* ptr, int row)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->rowMinimumHeight(row);
}

double QGraphicsGridLayout_RowPreferredHeight(void* ptr, int row)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->rowPreferredHeight(row);
}

double QGraphicsGridLayout_RowSpacing(void* ptr, int row)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->rowSpacing(row);
}

int QGraphicsGridLayout_RowStretchFactor(void* ptr, int row)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->rowStretchFactor(row);
}

void QGraphicsGridLayout_SetAlignment(void* ptr, void* item, long long alignment)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsGridLayout*>(ptr)->setAlignment(static_cast<QGraphicsWidget*>(item), static_cast<Qt::AlignmentFlag>(alignment));
	} else {
		static_cast<QGraphicsGridLayout*>(ptr)->setAlignment(static_cast<QGraphicsLayoutItem*>(item), static_cast<Qt::AlignmentFlag>(alignment));
	}
}

void QGraphicsGridLayout_SetColumnAlignment(void* ptr, int column, long long alignment)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setColumnAlignment(column, static_cast<Qt::AlignmentFlag>(alignment));
}

void QGraphicsGridLayout_SetColumnFixedWidth(void* ptr, int column, double width)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setColumnFixedWidth(column, width);
}

void QGraphicsGridLayout_SetColumnMaximumWidth(void* ptr, int column, double width)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setColumnMaximumWidth(column, width);
}

void QGraphicsGridLayout_SetColumnMinimumWidth(void* ptr, int column, double width)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setColumnMinimumWidth(column, width);
}

void QGraphicsGridLayout_SetColumnPreferredWidth(void* ptr, int column, double width)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setColumnPreferredWidth(column, width);
}

void QGraphicsGridLayout_SetColumnSpacing(void* ptr, int column, double spacing)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setColumnSpacing(column, spacing);
}

void QGraphicsGridLayout_SetColumnStretchFactor(void* ptr, int column, int stretch)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setColumnStretchFactor(column, stretch);
}

void QGraphicsGridLayout_SetHorizontalSpacing(void* ptr, double spacing)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setHorizontalSpacing(spacing);
}

void QGraphicsGridLayout_SetRowAlignment(void* ptr, int row, long long alignment)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setRowAlignment(row, static_cast<Qt::AlignmentFlag>(alignment));
}

void QGraphicsGridLayout_SetRowFixedHeight(void* ptr, int row, double height)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setRowFixedHeight(row, height);
}

void QGraphicsGridLayout_SetRowMaximumHeight(void* ptr, int row, double height)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setRowMaximumHeight(row, height);
}

void QGraphicsGridLayout_SetRowMinimumHeight(void* ptr, int row, double height)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setRowMinimumHeight(row, height);
}

void QGraphicsGridLayout_SetRowPreferredHeight(void* ptr, int row, double height)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setRowPreferredHeight(row, height);
}

void QGraphicsGridLayout_SetRowSpacing(void* ptr, int row, double spacing)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setRowSpacing(row, spacing);
}

void QGraphicsGridLayout_SetRowStretchFactor(void* ptr, int row, int stretch)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setRowStretchFactor(row, stretch);
}

void QGraphicsGridLayout_SetSpacing(void* ptr, double spacing)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setSpacing(spacing);
}

void QGraphicsGridLayout_SetVerticalSpacing(void* ptr, double spacing)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setVerticalSpacing(spacing);
}

void* QGraphicsGridLayout_SizeHint(void* ptr, long long which, void* constraint)
{
	return ({ QSizeF tmpValue = static_cast<QGraphicsGridLayout*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsGridLayout_SizeHintDefault(void* ptr, long long which, void* constraint)
{
		return ({ QSizeF tmpValue = static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

double QGraphicsGridLayout_VerticalSpacing(void* ptr)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->verticalSpacing();
}

void QGraphicsGridLayout_DestroyQGraphicsGridLayout(void* ptr)
{
	static_cast<QGraphicsGridLayout*>(ptr)->~QGraphicsGridLayout();
}

void QGraphicsGridLayout_DestroyQGraphicsGridLayoutDefault(void* ptr)
{
	Q_UNUSED(ptr);

}





class MyQGraphicsItem: public QGraphicsItem
{
public:
	MyQGraphicsItem(QGraphicsItem *parent = Q_NULLPTR) : QGraphicsItem(parent) {QGraphicsItem_QGraphicsItem_QRegisterMetaType();};
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsItem_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
	 ~MyQGraphicsItem() { callbackQGraphicsItem_DestroyQGraphicsItem(this); };
};

Q_DECLARE_METATYPE(MyQGraphicsItem*)

int QGraphicsItem_QGraphicsItem_QRegisterMetaType(){qRegisterMetaType<QGraphicsItem*>(); return qRegisterMetaType<MyQGraphicsItem*>();}

void* QGraphicsItem_NewQGraphicsItem(void* parent)
{
	return new MyQGraphicsItem(static_cast<QGraphicsItem*>(parent));
}

char QGraphicsItem_AcceptDrops(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->acceptDrops();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->acceptDrops();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->acceptDrops();
	}
}

char QGraphicsItem_AcceptHoverEvents(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->acceptHoverEvents();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->acceptHoverEvents();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->acceptHoverEvents();
	}
}

char QGraphicsItem_AcceptTouchEvents(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->acceptTouchEvents();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->acceptTouchEvents();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->acceptTouchEvents();
	}
}

long long QGraphicsItem_AcceptedMouseButtons(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->acceptedMouseButtons();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->acceptedMouseButtons();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->acceptedMouseButtons();
	}
}

void QGraphicsItem_Advance(void* ptr, int phase)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->advance(phase);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->advance(phase);
	} else {
		static_cast<QGraphicsItem*>(ptr)->advance(phase);
	}
}

void QGraphicsItem_AdvanceDefault(void* ptr, int phase)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::advance(phase);
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::advance(phase);
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::advance(phase);
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::advance(phase);
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::advance(phase);
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::advance(phase);
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::advance(phase);
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::advance(phase);
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::advance(phase);
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::advance(phase);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::advance(phase);
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::advance(phase);
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::advance(phase);
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::advance(phase);
	}
}

void* QGraphicsItem_BoundingRect(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QGraphicsItem_BoundingRegion(void* ptr, void* itemToDeviceTransform)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QRegion(static_cast<QGraphicsObject*>(ptr)->boundingRegion(*static_cast<QTransform*>(itemToDeviceTransform)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QRegion(static_cast<QGraphicsWidget*>(ptr)->boundingRegion(*static_cast<QTransform*>(itemToDeviceTransform)));
	} else {
		return new QRegion(static_cast<QGraphicsItem*>(ptr)->boundingRegion(*static_cast<QTransform*>(itemToDeviceTransform)));
	}
}

double QGraphicsItem_BoundingRegionGranularity(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->boundingRegionGranularity();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->boundingRegionGranularity();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->boundingRegionGranularity();
	}
}

long long QGraphicsItem_CacheMode(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->cacheMode();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->cacheMode();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->cacheMode();
	}
}

struct QtWidgets_PackedList QGraphicsItem_ChildItems(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QGraphicsItem *>* tmpValue479dfb = new QList<QGraphicsItem *>(static_cast<QGraphicsObject*>(ptr)->childItems()); QtWidgets_PackedList { tmpValue479dfb, tmpValue479dfb->size() }; });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QGraphicsItem *>* tmpValue479dfb = new QList<QGraphicsItem *>(static_cast<QGraphicsWidget*>(ptr)->childItems()); QtWidgets_PackedList { tmpValue479dfb, tmpValue479dfb->size() }; });
	} else {
		return ({ QList<QGraphicsItem *>* tmpValue479dfb = new QList<QGraphicsItem *>(static_cast<QGraphicsItem*>(ptr)->childItems()); QtWidgets_PackedList { tmpValue479dfb, tmpValue479dfb->size() }; });
	}
}

void* QGraphicsItem_ChildrenBoundingRect(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->childrenBoundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->childrenBoundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->childrenBoundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void QGraphicsItem_ClearFocus(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->clearFocus();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->clearFocus();
	} else {
		static_cast<QGraphicsItem*>(ptr)->clearFocus();
	}
}

void* QGraphicsItem_ClipPath(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->clipPath());
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->clipPath());
	} else {
		return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->clipPath());
	}
}

char QGraphicsItem_CollidesWithItem(void* ptr, void* other, long long mode)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsObject*>(ptr)->collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsObject*>(ptr)->collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsObject*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsWidget*>(ptr)->collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsWidget*>(ptr)->collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsWidget*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsItem*>(ptr)->collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsItem*>(ptr)->collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	}
}

char QGraphicsItem_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::collidesWithItem(static_cast<QGraphicsObject*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::collidesWithItem(static_cast<QGraphicsWidget*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		} else {
			return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
		}
	}
}

char QGraphicsItem_CollidesWithPath(void* ptr, void* path, long long mode)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else {
		return static_cast<QGraphicsItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	}
}

char QGraphicsItem_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	} else {
		return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
	}
}

struct QtWidgets_PackedList QGraphicsItem_CollidingItems(void* ptr, long long mode)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QGraphicsItem *>* tmpValue8b585f = new QList<QGraphicsItem *>(static_cast<QGraphicsObject*>(ptr)->collidingItems(static_cast<Qt::ItemSelectionMode>(mode))); QtWidgets_PackedList { tmpValue8b585f, tmpValue8b585f->size() }; });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QGraphicsItem *>* tmpValue8b585f = new QList<QGraphicsItem *>(static_cast<QGraphicsWidget*>(ptr)->collidingItems(static_cast<Qt::ItemSelectionMode>(mode))); QtWidgets_PackedList { tmpValue8b585f, tmpValue8b585f->size() }; });
	} else {
		return ({ QList<QGraphicsItem *>* tmpValue8b585f = new QList<QGraphicsItem *>(static_cast<QGraphicsItem*>(ptr)->collidingItems(static_cast<Qt::ItemSelectionMode>(mode))); QtWidgets_PackedList { tmpValue8b585f, tmpValue8b585f->size() }; });
	}
}

void* QGraphicsItem_CommonAncestorItem(void* ptr, void* other)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsObject*>(ptr)->commonAncestorItem(static_cast<QGraphicsObject*>(other));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsObject*>(ptr)->commonAncestorItem(static_cast<QGraphicsWidget*>(other));
		} else {
			return static_cast<QGraphicsObject*>(ptr)->commonAncestorItem(static_cast<QGraphicsItem*>(other));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsWidget*>(ptr)->commonAncestorItem(static_cast<QGraphicsObject*>(other));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsWidget*>(ptr)->commonAncestorItem(static_cast<QGraphicsWidget*>(other));
		} else {
			return static_cast<QGraphicsWidget*>(ptr)->commonAncestorItem(static_cast<QGraphicsItem*>(other));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsItem*>(ptr)->commonAncestorItem(static_cast<QGraphicsObject*>(other));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return static_cast<QGraphicsItem*>(ptr)->commonAncestorItem(static_cast<QGraphicsWidget*>(other));
		} else {
			return static_cast<QGraphicsItem*>(ptr)->commonAncestorItem(static_cast<QGraphicsItem*>(other));
		}
	}
}

char QGraphicsItem_Contains(void* ptr, void* point)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->contains(*static_cast<QPointF*>(point));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->contains(*static_cast<QPointF*>(point));
	} else {
		return static_cast<QGraphicsItem*>(ptr)->contains(*static_cast<QPointF*>(point));
	}
}

char QGraphicsItem_ContainsDefault(void* ptr, void* point)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::contains(*static_cast<QPointF*>(point));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::contains(*static_cast<QPointF*>(point));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::contains(*static_cast<QPointF*>(point));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::contains(*static_cast<QPointF*>(point));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::contains(*static_cast<QPointF*>(point));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::contains(*static_cast<QPointF*>(point));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::contains(*static_cast<QPointF*>(point));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::contains(*static_cast<QPointF*>(point));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::contains(*static_cast<QPointF*>(point));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::contains(*static_cast<QPointF*>(point));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::contains(*static_cast<QPointF*>(point));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::contains(*static_cast<QPointF*>(point));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::contains(*static_cast<QPointF*>(point));
	} else {
		return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::contains(*static_cast<QPointF*>(point));
	}
}

void QGraphicsItem_ContextMenuEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	}
}

void QGraphicsItem_ContextMenuEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
	}
}

void* QGraphicsItem_Cursor(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QCursor(static_cast<QGraphicsObject*>(ptr)->cursor());
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QCursor(static_cast<QGraphicsWidget*>(ptr)->cursor());
	} else {
		return new QCursor(static_cast<QGraphicsItem*>(ptr)->cursor());
	}
}

void* QGraphicsItem_Data(void* ptr, int key)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsObject*>(ptr)->data(key));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsWidget*>(ptr)->data(key));
	} else {
		return new QVariant(static_cast<QGraphicsItem*>(ptr)->data(key));
	}
}

void* QGraphicsItem_DeviceTransform(void* ptr, void* viewportTransform)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QTransform(static_cast<QGraphicsObject*>(ptr)->deviceTransform(*static_cast<QTransform*>(viewportTransform)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QTransform(static_cast<QGraphicsWidget*>(ptr)->deviceTransform(*static_cast<QTransform*>(viewportTransform)));
	} else {
		return new QTransform(static_cast<QGraphicsItem*>(ptr)->deviceTransform(*static_cast<QTransform*>(viewportTransform)));
	}
}

void QGraphicsItem_DragEnterEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	}
}

void QGraphicsItem_DragEnterEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	}
}

void QGraphicsItem_DragLeaveEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	}
}

void QGraphicsItem_DragLeaveEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	}
}

void QGraphicsItem_DragMoveEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	}
}

void QGraphicsItem_DragMoveEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	}
}

void QGraphicsItem_DropEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	}
}

void QGraphicsItem_DropEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
	}
}

double QGraphicsItem_EffectiveOpacity(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->effectiveOpacity();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->effectiveOpacity();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->effectiveOpacity();
	}
}

void QGraphicsItem_EnsureVisible(void* ptr, void* rect, int xmargin, int ymargin)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->ensureVisible(*static_cast<QRectF*>(rect), xmargin, ymargin);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->ensureVisible(*static_cast<QRectF*>(rect), xmargin, ymargin);
	} else {
		static_cast<QGraphicsItem*>(ptr)->ensureVisible(*static_cast<QRectF*>(rect), xmargin, ymargin);
	}
}

void QGraphicsItem_EnsureVisible2(void* ptr, double x, double y, double w, double h, int xmargin, int ymargin)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->ensureVisible(x, y, w, h, xmargin, ymargin);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->ensureVisible(x, y, w, h, xmargin, ymargin);
	} else {
		static_cast<QGraphicsItem*>(ptr)->ensureVisible(x, y, w, h, xmargin, ymargin);
	}
}

char QGraphicsItem_FiltersChildEvents(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->filtersChildEvents();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->filtersChildEvents();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->filtersChildEvents();
	}
}

long long QGraphicsItem_Flags(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->flags();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->flags();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->flags();
	}
}

void QGraphicsItem_FocusInEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
	}
}

void QGraphicsItem_FocusInEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::focusInEvent(static_cast<QFocusEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::focusInEvent(static_cast<QFocusEvent*>(event));
	}
}

void* QGraphicsItem_FocusItem(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->focusItem();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->focusItem();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->focusItem();
	}
}

void QGraphicsItem_FocusOutEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
	}
}

void QGraphicsItem_FocusOutEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::focusOutEvent(static_cast<QFocusEvent*>(event));
	}
}

void* QGraphicsItem_FocusProxy(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->focusProxy();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->focusProxy();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->focusProxy();
	}
}

void QGraphicsItem_GrabKeyboard(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->grabKeyboard();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->grabKeyboard();
	} else {
		static_cast<QGraphicsItem*>(ptr)->grabKeyboard();
	}
}

void QGraphicsItem_GrabMouse(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->grabMouse();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->grabMouse();
	} else {
		static_cast<QGraphicsItem*>(ptr)->grabMouse();
	}
}

void* QGraphicsItem_GraphicsEffect(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->graphicsEffect();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->graphicsEffect();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->graphicsEffect();
	}
}

void* QGraphicsItem_Group(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->group();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->group();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->group();
	}
}

char QGraphicsItem_HasCursor(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->hasCursor();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->hasCursor();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->hasCursor();
	}
}

char QGraphicsItem_HasFocus(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->hasFocus();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->hasFocus();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->hasFocus();
	}
}

void QGraphicsItem_Hide(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->hide();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->hide();
	} else {
		static_cast<QGraphicsItem*>(ptr)->hide();
	}
}

void QGraphicsItem_HoverEnterEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	}
}

void QGraphicsItem_HoverEnterEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	}
}

void QGraphicsItem_HoverLeaveEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	}
}

void QGraphicsItem_HoverLeaveEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	}
}

void QGraphicsItem_HoverMoveEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	}
}

void QGraphicsItem_HoverMoveEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
	}
}

void QGraphicsItem_InputMethodEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	}
}

void QGraphicsItem_InputMethodEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	}
}

long long QGraphicsItem_InputMethodHints(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->inputMethodHints();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->inputMethodHints();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->inputMethodHints();
	}
}

void* QGraphicsItem_InputMethodQuery(void* ptr, long long query)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsObject*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else {
		return new QVariant(static_cast<QGraphicsItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	}
}

void* QGraphicsItem_InputMethodQueryDefault(void* ptr, long long query)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else {
		return new QVariant(static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	}
}

void QGraphicsItem_InstallSceneEventFilter(void* ptr, void* filterItem)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(filterItem))) {
			static_cast<QGraphicsObject*>(ptr)->installSceneEventFilter(static_cast<QGraphicsObject*>(filterItem));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(filterItem))) {
			static_cast<QGraphicsObject*>(ptr)->installSceneEventFilter(static_cast<QGraphicsWidget*>(filterItem));
		} else {
			static_cast<QGraphicsObject*>(ptr)->installSceneEventFilter(static_cast<QGraphicsItem*>(filterItem));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(filterItem))) {
			static_cast<QGraphicsWidget*>(ptr)->installSceneEventFilter(static_cast<QGraphicsObject*>(filterItem));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(filterItem))) {
			static_cast<QGraphicsWidget*>(ptr)->installSceneEventFilter(static_cast<QGraphicsWidget*>(filterItem));
		} else {
			static_cast<QGraphicsWidget*>(ptr)->installSceneEventFilter(static_cast<QGraphicsItem*>(filterItem));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(filterItem))) {
			static_cast<QGraphicsItem*>(ptr)->installSceneEventFilter(static_cast<QGraphicsObject*>(filterItem));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(filterItem))) {
			static_cast<QGraphicsItem*>(ptr)->installSceneEventFilter(static_cast<QGraphicsWidget*>(filterItem));
		} else {
			static_cast<QGraphicsItem*>(ptr)->installSceneEventFilter(static_cast<QGraphicsItem*>(filterItem));
		}
	}
}

char QGraphicsItem_IsActive(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->isActive();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isActive();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->isActive();
	}
}

char QGraphicsItem_IsAncestorOf(void* ptr, void* child)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(child))) {
			return static_cast<QGraphicsObject*>(ptr)->isAncestorOf(static_cast<QGraphicsObject*>(child));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(child))) {
			return static_cast<QGraphicsObject*>(ptr)->isAncestorOf(static_cast<QGraphicsWidget*>(child));
		} else {
			return static_cast<QGraphicsObject*>(ptr)->isAncestorOf(static_cast<QGraphicsItem*>(child));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(child))) {
			return static_cast<QGraphicsWidget*>(ptr)->isAncestorOf(static_cast<QGraphicsObject*>(child));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(child))) {
			return static_cast<QGraphicsWidget*>(ptr)->isAncestorOf(static_cast<QGraphicsWidget*>(child));
		} else {
			return static_cast<QGraphicsWidget*>(ptr)->isAncestorOf(static_cast<QGraphicsItem*>(child));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(child))) {
			return static_cast<QGraphicsItem*>(ptr)->isAncestorOf(static_cast<QGraphicsObject*>(child));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(child))) {
			return static_cast<QGraphicsItem*>(ptr)->isAncestorOf(static_cast<QGraphicsWidget*>(child));
		} else {
			return static_cast<QGraphicsItem*>(ptr)->isAncestorOf(static_cast<QGraphicsItem*>(child));
		}
	}
}

char QGraphicsItem_IsClipped(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->isClipped();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isClipped();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->isClipped();
	}
}

char QGraphicsItem_IsEnabled(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->isEnabled();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isEnabled();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->isEnabled();
	}
}

char QGraphicsItem_IsObscured(void* ptr, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->isObscured(*static_cast<QRectF*>(rect));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isObscured(*static_cast<QRectF*>(rect));
	} else {
		return static_cast<QGraphicsItem*>(ptr)->isObscured(*static_cast<QRectF*>(rect));
	}
}

char QGraphicsItem_IsObscured2(void* ptr, double x, double y, double w, double h)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->isObscured(x, y, w, h);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isObscured(x, y, w, h);
	} else {
		return static_cast<QGraphicsItem*>(ptr)->isObscured(x, y, w, h);
	}
}

char QGraphicsItem_IsObscuredBy(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsObject*>(ptr)->isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsObject*>(ptr)->isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsObject*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsWidget*>(ptr)->isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsWidget*>(ptr)->isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsWidget*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsItem*>(ptr)->isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsItem*>(ptr)->isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	}
}

char QGraphicsItem_IsObscuredByDefault(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::isObscuredBy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::isObscuredBy(static_cast<QGraphicsWidget*>(item));
		} else {
			return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
		}
	}
}

char QGraphicsItem_IsPanel(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->isPanel();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isPanel();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->isPanel();
	}
}

char QGraphicsItem_IsSelected(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->isSelected();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isSelected();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->isSelected();
	}
}

char QGraphicsItem_IsUnderMouse(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->isUnderMouse();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isUnderMouse();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->isUnderMouse();
	}
}

char QGraphicsItem_IsVisible(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->isVisible();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isVisible();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->isVisible();
	}
}

char QGraphicsItem_IsVisibleTo(void* ptr, void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
			return static_cast<QGraphicsObject*>(ptr)->isVisibleTo(static_cast<QGraphicsObject*>(parent));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
			return static_cast<QGraphicsObject*>(ptr)->isVisibleTo(static_cast<QGraphicsWidget*>(parent));
		} else {
			return static_cast<QGraphicsObject*>(ptr)->isVisibleTo(static_cast<QGraphicsItem*>(parent));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
			return static_cast<QGraphicsWidget*>(ptr)->isVisibleTo(static_cast<QGraphicsObject*>(parent));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
			return static_cast<QGraphicsWidget*>(ptr)->isVisibleTo(static_cast<QGraphicsWidget*>(parent));
		} else {
			return static_cast<QGraphicsWidget*>(ptr)->isVisibleTo(static_cast<QGraphicsItem*>(parent));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
			return static_cast<QGraphicsItem*>(ptr)->isVisibleTo(static_cast<QGraphicsObject*>(parent));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
			return static_cast<QGraphicsItem*>(ptr)->isVisibleTo(static_cast<QGraphicsWidget*>(parent));
		} else {
			return static_cast<QGraphicsItem*>(ptr)->isVisibleTo(static_cast<QGraphicsItem*>(parent));
		}
	}
}

char QGraphicsItem_IsWidget(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->isWidget();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isWidget();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->isWidget();
	}
}

char QGraphicsItem_IsWindow(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->isWindow();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isWindow();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->isWindow();
	}
}

void* QGraphicsItem_ItemChange(void* ptr, long long change, void* value)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsObject*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsWidget*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else {
		return new QVariant(static_cast<QGraphicsItem*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	}
}

void* QGraphicsItem_ItemChangeDefault(void* ptr, long long change, void* value)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QVariant(static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	} else {
		return new QVariant(static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
	}
}

void* QGraphicsItem_ItemTransform(void* ptr, void* other, char* ok)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return new QTransform(static_cast<QGraphicsObject*>(ptr)->itemTransform(static_cast<QGraphicsObject*>(other), reinterpret_cast<bool*>(ok)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return new QTransform(static_cast<QGraphicsObject*>(ptr)->itemTransform(static_cast<QGraphicsWidget*>(other), reinterpret_cast<bool*>(ok)));
		} else {
			return new QTransform(static_cast<QGraphicsObject*>(ptr)->itemTransform(static_cast<QGraphicsItem*>(other), reinterpret_cast<bool*>(ok)));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return new QTransform(static_cast<QGraphicsWidget*>(ptr)->itemTransform(static_cast<QGraphicsObject*>(other), reinterpret_cast<bool*>(ok)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return new QTransform(static_cast<QGraphicsWidget*>(ptr)->itemTransform(static_cast<QGraphicsWidget*>(other), reinterpret_cast<bool*>(ok)));
		} else {
			return new QTransform(static_cast<QGraphicsWidget*>(ptr)->itemTransform(static_cast<QGraphicsItem*>(other), reinterpret_cast<bool*>(ok)));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(other))) {
			return new QTransform(static_cast<QGraphicsItem*>(ptr)->itemTransform(static_cast<QGraphicsObject*>(other), reinterpret_cast<bool*>(ok)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(other))) {
			return new QTransform(static_cast<QGraphicsItem*>(ptr)->itemTransform(static_cast<QGraphicsWidget*>(other), reinterpret_cast<bool*>(ok)));
		} else {
			return new QTransform(static_cast<QGraphicsItem*>(ptr)->itemTransform(static_cast<QGraphicsItem*>(other), reinterpret_cast<bool*>(ok)));
		}
	}
}

void QGraphicsItem_KeyPressEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
	}
}

void QGraphicsItem_KeyPressEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::keyPressEvent(static_cast<QKeyEvent*>(event));
	}
}

void QGraphicsItem_KeyReleaseEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
	}
}

void QGraphicsItem_KeyReleaseEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	}
}

void* QGraphicsItem_MapFromItem(void* ptr, void* item, void* point)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else {
			return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else {
			return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else {
			return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		}
	}
}

void* QGraphicsItem_MapFromItem2(void* ptr, void* item, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QRectF*>(rect)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QRectF*>(rect)));
		} else {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QRectF*>(rect)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QRectF*>(rect)));
		} else {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QRectF*>(rect)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QRectF*>(rect)));
		} else {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)));
		}
	}
}

void* QGraphicsItem_MapFromItem3(void* ptr, void* item, void* polygon)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QPolygonF*>(polygon)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPolygonF*>(polygon)));
		} else {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPolygonF*>(polygon)));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QPolygonF*>(polygon)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPolygonF*>(polygon)));
		} else {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPolygonF*>(polygon)));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QPolygonF*>(polygon)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPolygonF*>(polygon)));
		} else {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPolygonF*>(polygon)));
		}
	}
}

void* QGraphicsItem_MapFromItem4(void* ptr, void* item, void* path)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QPainterPath*>(path)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPainterPath*>(path)));
		} else {
			return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPainterPath*>(path)));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QPainterPath*>(path)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPainterPath*>(path)));
		} else {
			return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPainterPath*>(path)));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QPainterPath*>(path)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPainterPath*>(path)));
		} else {
			return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPainterPath*>(path)));
		}
	}
}

void* QGraphicsItem_MapFromItem5(void* ptr, void* item, double x, double y)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else {
			return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else {
			return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else {
			return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		}
	}
}

void* QGraphicsItem_MapFromItem6(void* ptr, void* item, double x, double y, double w, double h)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), x, y, w, h));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), x, y, w, h));
		} else {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), x, y, w, h));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), x, y, w, h));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), x, y, w, h));
		} else {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), x, y, w, h));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsObject*>(item), x, y, w, h));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsWidget*>(item), x, y, w, h));
		} else {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), x, y, w, h));
		}
	}
}

void* QGraphicsItem_MapFromParent(void* ptr, void* point)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapFromParent(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapFromParent(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromParent(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
	}
}

void* QGraphicsItem_MapFromParent2(void* ptr, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromParent(*static_cast<QRectF*>(rect)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromParent(*static_cast<QRectF*>(rect)));
	} else {
		return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromParent(*static_cast<QRectF*>(rect)));
	}
}

void* QGraphicsItem_MapFromParent3(void* ptr, void* polygon)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromParent(*static_cast<QPolygonF*>(polygon)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromParent(*static_cast<QPolygonF*>(polygon)));
	} else {
		return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromParent(*static_cast<QPolygonF*>(polygon)));
	}
}

void* QGraphicsItem_MapFromParent4(void* ptr, void* path)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->mapFromParent(*static_cast<QPainterPath*>(path)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->mapFromParent(*static_cast<QPainterPath*>(path)));
	} else {
		return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapFromParent(*static_cast<QPainterPath*>(path)));
	}
}

void* QGraphicsItem_MapFromParent5(void* ptr, double x, double y)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapFromParent(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapFromParent(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromParent(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
	}
}

void* QGraphicsItem_MapFromParent6(void* ptr, double x, double y, double w, double h)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromParent(x, y, w, h));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromParent(x, y, w, h));
	} else {
		return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromParent(x, y, w, h));
	}
}

void* QGraphicsItem_MapFromScene(void* ptr, void* point)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapFromScene(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapFromScene(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromScene(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
	}
}

void* QGraphicsItem_MapFromScene2(void* ptr, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromScene(*static_cast<QRectF*>(rect)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromScene(*static_cast<QRectF*>(rect)));
	} else {
		return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromScene(*static_cast<QRectF*>(rect)));
	}
}

void* QGraphicsItem_MapFromScene3(void* ptr, void* polygon)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromScene(*static_cast<QPolygonF*>(polygon)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromScene(*static_cast<QPolygonF*>(polygon)));
	} else {
		return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromScene(*static_cast<QPolygonF*>(polygon)));
	}
}

void* QGraphicsItem_MapFromScene4(void* ptr, void* path)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->mapFromScene(*static_cast<QPainterPath*>(path)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->mapFromScene(*static_cast<QPainterPath*>(path)));
	} else {
		return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapFromScene(*static_cast<QPainterPath*>(path)));
	}
}

void* QGraphicsItem_MapFromScene5(void* ptr, double x, double y)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapFromScene(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapFromScene(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromScene(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
	}
}

void* QGraphicsItem_MapFromScene6(void* ptr, double x, double y, double w, double h)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapFromScene(x, y, w, h));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapFromScene(x, y, w, h));
	} else {
		return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromScene(x, y, w, h));
	}
}

void* QGraphicsItem_MapRectFromItem(void* ptr, void* item, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else {
			return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else {
			return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsObject*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsWidget*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else {
			return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		}
	}
}

void* QGraphicsItem_MapRectFromItem2(void* ptr, void* item, double x, double y, double w, double h)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectFromItem(static_cast<QGraphicsObject*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectFromItem(static_cast<QGraphicsWidget*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else {
			return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectFromItem(static_cast<QGraphicsObject*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectFromItem(static_cast<QGraphicsWidget*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else {
			return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsObject*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsWidget*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else {
			return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		}
	}
}

void* QGraphicsItem_MapRectFromParent(void* ptr, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectFromParent(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectFromParent(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectFromParent(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QGraphicsItem_MapRectFromParent2(void* ptr, double x, double y, double w, double h)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectFromParent(x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectFromParent(x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectFromParent(x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QGraphicsItem_MapRectFromScene(void* ptr, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectFromScene(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectFromScene(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectFromScene(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QGraphicsItem_MapRectFromScene2(void* ptr, double x, double y, double w, double h)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectFromScene(x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectFromScene(x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectFromScene(x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QGraphicsItem_MapRectToItem(void* ptr, void* item, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectToItem(static_cast<QGraphicsObject*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else {
			return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectToItem(static_cast<QGraphicsObject*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else {
			return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsObject*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else {
			return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		}
	}
}

void* QGraphicsItem_MapRectToItem2(void* ptr, void* item, double x, double y, double w, double h)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectToItem(static_cast<QGraphicsObject*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectToItem(static_cast<QGraphicsWidget*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else {
			return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectToItem(static_cast<QGraphicsObject*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectToItem(static_cast<QGraphicsWidget*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else {
			return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsObject*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsWidget*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		} else {
			return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
		}
	}
}

void* QGraphicsItem_MapRectToParent(void* ptr, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectToParent(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectToParent(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectToParent(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QGraphicsItem_MapRectToParent2(void* ptr, double x, double y, double w, double h)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectToParent(x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectToParent(x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectToParent(x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QGraphicsItem_MapRectToScene(void* ptr, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectToScene(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectToScene(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectToScene(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QGraphicsItem_MapRectToScene2(void* ptr, double x, double y, double w, double h)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapRectToScene(x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapRectToScene(x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectToScene(x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QGraphicsItem_MapToItem(void* ptr, void* item, void* point)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else {
			return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else {
			return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else {
			return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
		}
	}
}

void* QGraphicsItem_MapToItem2(void* ptr, void* item, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), *static_cast<QRectF*>(rect)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QRectF*>(rect)));
		} else {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), *static_cast<QRectF*>(rect)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QRectF*>(rect)));
		} else {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), *static_cast<QRectF*>(rect)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QRectF*>(rect)));
		} else {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)));
		}
	}
}

void* QGraphicsItem_MapToItem3(void* ptr, void* item, void* polygon)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), *static_cast<QPolygonF*>(polygon)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPolygonF*>(polygon)));
		} else {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPolygonF*>(polygon)));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), *static_cast<QPolygonF*>(polygon)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPolygonF*>(polygon)));
		} else {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPolygonF*>(polygon)));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), *static_cast<QPolygonF*>(polygon)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPolygonF*>(polygon)));
		} else {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPolygonF*>(polygon)));
		}
	}
}

void* QGraphicsItem_MapToItem4(void* ptr, void* item, void* path)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), *static_cast<QPainterPath*>(path)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPainterPath*>(path)));
		} else {
			return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPainterPath*>(path)));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), *static_cast<QPainterPath*>(path)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPainterPath*>(path)));
		} else {
			return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPainterPath*>(path)));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), *static_cast<QPainterPath*>(path)));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), *static_cast<QPainterPath*>(path)));
		} else {
			return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPainterPath*>(path)));
		}
	}
}

void* QGraphicsItem_MapToItem5(void* ptr, void* item, double x, double y)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else {
			return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else {
			return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		} else {
			return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
		}
	}
}

void* QGraphicsItem_MapToItem6(void* ptr, void* item, double x, double y, double w, double h)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), x, y, w, h));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), x, y, w, h));
		} else {
			return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), x, y, w, h));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), x, y, w, h));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), x, y, w, h));
		} else {
			return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), x, y, w, h));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsObject*>(item), x, y, w, h));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsWidget*>(item), x, y, w, h));
		} else {
			return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), x, y, w, h));
		}
	}
}

void* QGraphicsItem_MapToParent(void* ptr, void* point)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapToParent(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapToParent(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToParent(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
	}
}

void* QGraphicsItem_MapToParent2(void* ptr, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToParent(*static_cast<QRectF*>(rect)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToParent(*static_cast<QRectF*>(rect)));
	} else {
		return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToParent(*static_cast<QRectF*>(rect)));
	}
}

void* QGraphicsItem_MapToParent3(void* ptr, void* polygon)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToParent(*static_cast<QPolygonF*>(polygon)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToParent(*static_cast<QPolygonF*>(polygon)));
	} else {
		return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToParent(*static_cast<QPolygonF*>(polygon)));
	}
}

void* QGraphicsItem_MapToParent4(void* ptr, void* path)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->mapToParent(*static_cast<QPainterPath*>(path)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->mapToParent(*static_cast<QPainterPath*>(path)));
	} else {
		return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapToParent(*static_cast<QPainterPath*>(path)));
	}
}

void* QGraphicsItem_MapToParent5(void* ptr, double x, double y)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapToParent(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapToParent(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToParent(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
	}
}

void* QGraphicsItem_MapToParent6(void* ptr, double x, double y, double w, double h)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToParent(x, y, w, h));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToParent(x, y, w, h));
	} else {
		return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToParent(x, y, w, h));
	}
}

void* QGraphicsItem_MapToScene(void* ptr, void* point)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapToScene(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapToScene(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToScene(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
	}
}

void* QGraphicsItem_MapToScene2(void* ptr, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToScene(*static_cast<QRectF*>(rect)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToScene(*static_cast<QRectF*>(rect)));
	} else {
		return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToScene(*static_cast<QRectF*>(rect)));
	}
}

void* QGraphicsItem_MapToScene3(void* ptr, void* polygon)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToScene(*static_cast<QPolygonF*>(polygon)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToScene(*static_cast<QPolygonF*>(polygon)));
	} else {
		return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToScene(*static_cast<QPolygonF*>(polygon)));
	}
}

void* QGraphicsItem_MapToScene4(void* ptr, void* path)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->mapToScene(*static_cast<QPainterPath*>(path)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->mapToScene(*static_cast<QPainterPath*>(path)));
	} else {
		return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapToScene(*static_cast<QPainterPath*>(path)));
	}
}

void* QGraphicsItem_MapToScene5(void* ptr, double x, double y)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->mapToScene(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->mapToScene(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToScene(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
	}
}

void* QGraphicsItem_MapToScene6(void* ptr, double x, double y, double w, double h)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsObject*>(ptr)->mapToScene(x, y, w, h));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPolygonF(static_cast<QGraphicsWidget*>(ptr)->mapToScene(x, y, w, h));
	} else {
		return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToScene(x, y, w, h));
	}
}

void QGraphicsItem_MouseDoubleClickEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	}
}

void QGraphicsItem_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	}
}

void QGraphicsItem_MouseMoveEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	}
}

void QGraphicsItem_MouseMoveEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	}
}

void QGraphicsItem_MousePressEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	}
}

void QGraphicsItem_MousePressEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	}
}

void QGraphicsItem_MouseReleaseEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	}
}

void QGraphicsItem_MouseReleaseEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
	}
}

void QGraphicsItem_MoveBy(void* ptr, double dx, double dy)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->moveBy(dx, dy);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->moveBy(dx, dy);
	} else {
		static_cast<QGraphicsItem*>(ptr)->moveBy(dx, dy);
	}
}

double QGraphicsItem_Opacity(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->opacity();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->opacity();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->opacity();
	}
}

void* QGraphicsItem_OpaqueArea(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->opaqueArea());
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->opaqueArea());
	} else {
		return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->opaqueArea());
	}
}

void* QGraphicsItem_OpaqueAreaDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::opaqueArea());
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::opaqueArea());
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::opaqueArea());
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::opaqueArea());
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::opaqueArea());
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::opaqueArea());
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::opaqueArea());
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::opaqueArea());
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::opaqueArea());
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::opaqueArea());
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::opaqueArea());
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::opaqueArea());
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::opaqueArea());
	} else {
		return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::opaqueArea());
	}
}

void QGraphicsItem_Paint(void* ptr, void* painter, void* option, void* widget)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	} else {
		static_cast<QGraphicsItem*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	}
}

void* QGraphicsItem_Panel(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->panel();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->panel();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->panel();
	}
}

long long QGraphicsItem_PanelModality(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->panelModality();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->panelModality();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->panelModality();
	}
}

void* QGraphicsItem_ParentItem(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->parentItem();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->parentItem();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->parentItem();
	}
}

void* QGraphicsItem_ParentObject(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->parentObject();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->parentObject();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->parentObject();
	}
}

void* QGraphicsItem_ParentWidget(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->parentWidget();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->parentWidget();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->parentWidget();
	}
}

void* QGraphicsItem_Pos(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->pos(); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->pos(); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->pos(); new QPointF(tmpValue.x(), tmpValue.y()); });
	}
}

void QGraphicsItem_PrepareGeometryChange(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->prepareGeometryChange();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->prepareGeometryChange();
	} else {
		static_cast<QGraphicsItem*>(ptr)->prepareGeometryChange();
	}
}

void QGraphicsItem_RemoveSceneEventFilter(void* ptr, void* filterItem)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(filterItem))) {
			static_cast<QGraphicsObject*>(ptr)->removeSceneEventFilter(static_cast<QGraphicsObject*>(filterItem));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(filterItem))) {
			static_cast<QGraphicsObject*>(ptr)->removeSceneEventFilter(static_cast<QGraphicsWidget*>(filterItem));
		} else {
			static_cast<QGraphicsObject*>(ptr)->removeSceneEventFilter(static_cast<QGraphicsItem*>(filterItem));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(filterItem))) {
			static_cast<QGraphicsWidget*>(ptr)->removeSceneEventFilter(static_cast<QGraphicsObject*>(filterItem));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(filterItem))) {
			static_cast<QGraphicsWidget*>(ptr)->removeSceneEventFilter(static_cast<QGraphicsWidget*>(filterItem));
		} else {
			static_cast<QGraphicsWidget*>(ptr)->removeSceneEventFilter(static_cast<QGraphicsItem*>(filterItem));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(filterItem))) {
			static_cast<QGraphicsItem*>(ptr)->removeSceneEventFilter(static_cast<QGraphicsObject*>(filterItem));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(filterItem))) {
			static_cast<QGraphicsItem*>(ptr)->removeSceneEventFilter(static_cast<QGraphicsWidget*>(filterItem));
		} else {
			static_cast<QGraphicsItem*>(ptr)->removeSceneEventFilter(static_cast<QGraphicsItem*>(filterItem));
		}
	}
}

void QGraphicsItem_ResetTransform(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->resetTransform();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->resetTransform();
	} else {
		static_cast<QGraphicsItem*>(ptr)->resetTransform();
	}
}

double QGraphicsItem_Rotation(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->rotation();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->rotation();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->rotation();
	}
}

double QGraphicsItem_Scale2(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->scale();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->scale();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->scale();
	}
}

void* QGraphicsItem_Scene(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->scene();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->scene();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->scene();
	}
}

void* QGraphicsItem_SceneBoundingRect(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsObject*>(ptr)->sceneBoundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->sceneBoundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->sceneBoundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

char QGraphicsItem_SceneEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
	} else {
		return static_cast<QGraphicsItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
	}
}

char QGraphicsItem_SceneEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::sceneEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::sceneEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::sceneEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::sceneEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::sceneEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::sceneEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::sceneEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::sceneEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::sceneEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::sceneEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::sceneEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::sceneEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::sceneEvent(static_cast<QEvent*>(event));
	} else {
		return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::sceneEvent(static_cast<QEvent*>(event));
	}
}

char QGraphicsItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsObject*>(ptr)->sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsObject*>(ptr)->sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsObject*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsWidget*>(ptr)->sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsWidget*>(ptr)->sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsWidget*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	}
}

char QGraphicsItem_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::sceneEventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::sceneEventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void* QGraphicsItem_ScenePos(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->scenePos(); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->scenePos(); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->scenePos(); new QPointF(tmpValue.x(), tmpValue.y()); });
	}
}

void* QGraphicsItem_SceneTransform(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QTransform(static_cast<QGraphicsObject*>(ptr)->sceneTransform());
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QTransform(static_cast<QGraphicsWidget*>(ptr)->sceneTransform());
	} else {
		return new QTransform(static_cast<QGraphicsItem*>(ptr)->sceneTransform());
	}
}

void QGraphicsItem_Scroll(void* ptr, double dx, double dy, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->scroll(dx, dy, *static_cast<QRectF*>(rect));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->scroll(dx, dy, *static_cast<QRectF*>(rect));
	} else {
		static_cast<QGraphicsItem*>(ptr)->scroll(dx, dy, *static_cast<QRectF*>(rect));
	}
}

void QGraphicsItem_SetAcceptDrops(void* ptr, char on)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setAcceptDrops(on != 0);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setAcceptDrops(on != 0);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setAcceptDrops(on != 0);
	}
}

void QGraphicsItem_SetAcceptHoverEvents(void* ptr, char enabled)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setAcceptHoverEvents(enabled != 0);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setAcceptHoverEvents(enabled != 0);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setAcceptHoverEvents(enabled != 0);
	}
}

void QGraphicsItem_SetAcceptTouchEvents(void* ptr, char enabled)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setAcceptTouchEvents(enabled != 0);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setAcceptTouchEvents(enabled != 0);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setAcceptTouchEvents(enabled != 0);
	}
}

void QGraphicsItem_SetAcceptedMouseButtons(void* ptr, long long buttons)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setAcceptedMouseButtons(static_cast<Qt::MouseButton>(buttons));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setAcceptedMouseButtons(static_cast<Qt::MouseButton>(buttons));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setAcceptedMouseButtons(static_cast<Qt::MouseButton>(buttons));
	}
}

void QGraphicsItem_SetActive(void* ptr, char active)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setActive(active != 0);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setActive(active != 0);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setActive(active != 0);
	}
}

void QGraphicsItem_SetBoundingRegionGranularity(void* ptr, double granularity)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setBoundingRegionGranularity(granularity);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setBoundingRegionGranularity(granularity);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setBoundingRegionGranularity(granularity);
	}
}

void QGraphicsItem_SetCacheMode(void* ptr, long long mode, void* logicalCacheSize)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setCacheMode(static_cast<QGraphicsItem::CacheMode>(mode), *static_cast<QSize*>(logicalCacheSize));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setCacheMode(static_cast<QGraphicsItem::CacheMode>(mode), *static_cast<QSize*>(logicalCacheSize));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setCacheMode(static_cast<QGraphicsItem::CacheMode>(mode), *static_cast<QSize*>(logicalCacheSize));
	}
}

void QGraphicsItem_SetCursor(void* ptr, void* cursor)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setCursor(*static_cast<QCursor*>(cursor));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setCursor(*static_cast<QCursor*>(cursor));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setCursor(*static_cast<QCursor*>(cursor));
	}
}

void QGraphicsItem_SetData(void* ptr, int key, void* value)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setData(key, *static_cast<QVariant*>(value));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setData(key, *static_cast<QVariant*>(value));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setData(key, *static_cast<QVariant*>(value));
	}
}

void QGraphicsItem_SetEnabled(void* ptr, char enabled)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setEnabled(enabled != 0);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setEnabled(enabled != 0);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setEnabled(enabled != 0);
	}
}

void QGraphicsItem_SetFiltersChildEvents(void* ptr, char enabled)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setFiltersChildEvents(enabled != 0);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setFiltersChildEvents(enabled != 0);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setFiltersChildEvents(enabled != 0);
	}
}

void QGraphicsItem_SetFlag(void* ptr, long long flag, char enabled)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setFlag(static_cast<QGraphicsItem::GraphicsItemFlag>(flag), enabled != 0);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setFlag(static_cast<QGraphicsItem::GraphicsItemFlag>(flag), enabled != 0);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setFlag(static_cast<QGraphicsItem::GraphicsItemFlag>(flag), enabled != 0);
	}
}

void QGraphicsItem_SetFlags(void* ptr, long long flags)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setFlags(static_cast<QGraphicsItem::GraphicsItemFlag>(flags));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setFlags(static_cast<QGraphicsItem::GraphicsItemFlag>(flags));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setFlags(static_cast<QGraphicsItem::GraphicsItemFlag>(flags));
	}
}

void QGraphicsItem_SetFocus(void* ptr, long long focusReason)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setFocus(static_cast<Qt::FocusReason>(focusReason));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setFocus(static_cast<Qt::FocusReason>(focusReason));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setFocus(static_cast<Qt::FocusReason>(focusReason));
	}
}

void QGraphicsItem_SetFocusProxy(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			static_cast<QGraphicsObject*>(ptr)->setFocusProxy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			static_cast<QGraphicsObject*>(ptr)->setFocusProxy(static_cast<QGraphicsWidget*>(item));
		} else {
			static_cast<QGraphicsObject*>(ptr)->setFocusProxy(static_cast<QGraphicsItem*>(item));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			static_cast<QGraphicsWidget*>(ptr)->setFocusProxy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			static_cast<QGraphicsWidget*>(ptr)->setFocusProxy(static_cast<QGraphicsWidget*>(item));
		} else {
			static_cast<QGraphicsWidget*>(ptr)->setFocusProxy(static_cast<QGraphicsItem*>(item));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			static_cast<QGraphicsItem*>(ptr)->setFocusProxy(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			static_cast<QGraphicsItem*>(ptr)->setFocusProxy(static_cast<QGraphicsWidget*>(item));
		} else {
			static_cast<QGraphicsItem*>(ptr)->setFocusProxy(static_cast<QGraphicsItem*>(item));
		}
	}
}

void QGraphicsItem_SetGraphicsEffect(void* ptr, void* effect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setGraphicsEffect(static_cast<QGraphicsEffect*>(effect));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setGraphicsEffect(static_cast<QGraphicsEffect*>(effect));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setGraphicsEffect(static_cast<QGraphicsEffect*>(effect));
	}
}

void QGraphicsItem_SetGroup(void* ptr, void* group)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setGroup(static_cast<QGraphicsItemGroup*>(group));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setGroup(static_cast<QGraphicsItemGroup*>(group));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setGroup(static_cast<QGraphicsItemGroup*>(group));
	}
}

void QGraphicsItem_SetInputMethodHints(void* ptr, long long hints)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setInputMethodHints(static_cast<Qt::InputMethodHint>(hints));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setInputMethodHints(static_cast<Qt::InputMethodHint>(hints));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setInputMethodHints(static_cast<Qt::InputMethodHint>(hints));
	}
}

void QGraphicsItem_SetOpacity(void* ptr, double opacity)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setOpacity(opacity);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setOpacity(opacity);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setOpacity(opacity);
	}
}

void QGraphicsItem_SetPanelModality(void* ptr, long long panelModality)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setPanelModality(static_cast<QGraphicsItem::PanelModality>(panelModality));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setPanelModality(static_cast<QGraphicsItem::PanelModality>(panelModality));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setPanelModality(static_cast<QGraphicsItem::PanelModality>(panelModality));
	}
}

void QGraphicsItem_SetParentItem(void* ptr, void* newParent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(newParent))) {
			static_cast<QGraphicsObject*>(ptr)->setParentItem(static_cast<QGraphicsObject*>(newParent));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(newParent))) {
			static_cast<QGraphicsObject*>(ptr)->setParentItem(static_cast<QGraphicsWidget*>(newParent));
		} else {
			static_cast<QGraphicsObject*>(ptr)->setParentItem(static_cast<QGraphicsItem*>(newParent));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(newParent))) {
			static_cast<QGraphicsWidget*>(ptr)->setParentItem(static_cast<QGraphicsObject*>(newParent));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(newParent))) {
			static_cast<QGraphicsWidget*>(ptr)->setParentItem(static_cast<QGraphicsWidget*>(newParent));
		} else {
			static_cast<QGraphicsWidget*>(ptr)->setParentItem(static_cast<QGraphicsItem*>(newParent));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(newParent))) {
			static_cast<QGraphicsItem*>(ptr)->setParentItem(static_cast<QGraphicsObject*>(newParent));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(newParent))) {
			static_cast<QGraphicsItem*>(ptr)->setParentItem(static_cast<QGraphicsWidget*>(newParent));
		} else {
			static_cast<QGraphicsItem*>(ptr)->setParentItem(static_cast<QGraphicsItem*>(newParent));
		}
	}
}

void QGraphicsItem_SetPos(void* ptr, void* pos)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setPos(*static_cast<QPointF*>(pos));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setPos(*static_cast<QPointF*>(pos));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setPos(*static_cast<QPointF*>(pos));
	}
}

void QGraphicsItem_SetPos2(void* ptr, double x, double y)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setPos(x, y);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setPos(x, y);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setPos(x, y);
	}
}

void QGraphicsItem_SetRotation(void* ptr, double angle)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setRotation(angle);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setRotation(angle);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setRotation(angle);
	}
}

void QGraphicsItem_SetScale(void* ptr, double factor)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setScale(factor);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setScale(factor);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setScale(factor);
	}
}

void QGraphicsItem_SetSelected(void* ptr, char selected)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setSelected(selected != 0);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setSelected(selected != 0);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setSelected(selected != 0);
	}
}

void QGraphicsItem_SetToolTip(void* ptr, struct QtWidgets_PackedString toolTip)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setToolTip(QString::fromUtf8(toolTip.data, toolTip.len));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setToolTip(QString::fromUtf8(toolTip.data, toolTip.len));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setToolTip(QString::fromUtf8(toolTip.data, toolTip.len));
	}
}

void QGraphicsItem_SetTransform(void* ptr, void* matrix, char combine)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setTransform(*static_cast<QTransform*>(matrix), combine != 0);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setTransform(*static_cast<QTransform*>(matrix), combine != 0);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setTransform(*static_cast<QTransform*>(matrix), combine != 0);
	}
}

void QGraphicsItem_SetTransformOriginPoint(void* ptr, void* origin)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setTransformOriginPoint(*static_cast<QPointF*>(origin));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setTransformOriginPoint(*static_cast<QPointF*>(origin));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setTransformOriginPoint(*static_cast<QPointF*>(origin));
	}
}

void QGraphicsItem_SetTransformOriginPoint2(void* ptr, double x, double y)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setTransformOriginPoint(x, y);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setTransformOriginPoint(x, y);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setTransformOriginPoint(x, y);
	}
}

void QGraphicsItem_SetTransformations(void* ptr, void* transformations)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setTransformations(*static_cast<QList<QGraphicsTransform *>*>(transformations));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setTransformations(*static_cast<QList<QGraphicsTransform *>*>(transformations));
	} else {
		static_cast<QGraphicsItem*>(ptr)->setTransformations(*static_cast<QList<QGraphicsTransform *>*>(transformations));
	}
}

void QGraphicsItem_SetVisible(void* ptr, char visible)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setVisible(visible != 0);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setVisible(visible != 0);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setVisible(visible != 0);
	}
}

void QGraphicsItem_SetX(void* ptr, double x)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setX(x);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setX(x);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setX(x);
	}
}

void QGraphicsItem_SetY(void* ptr, double y)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setY(y);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setY(y);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setY(y);
	}
}

void QGraphicsItem_SetZValue(void* ptr, double z)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->setZValue(z);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setZValue(z);
	} else {
		static_cast<QGraphicsItem*>(ptr)->setZValue(z);
	}
}

void* QGraphicsItem_Shape(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->shape());
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->shape());
	} else {
		return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->shape());
	}
}

void* QGraphicsItem_ShapeDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::shape());
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::shape());
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::shape());
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::shape());
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::shape());
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::shape());
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::shape());
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::shape());
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return new QPainterPath(static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::shape());
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::shape());
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::shape());
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::shape());
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::shape());
	} else {
		return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::shape());
	}
}

void QGraphicsItem_Show(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->show();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->show();
	} else {
		static_cast<QGraphicsItem*>(ptr)->show();
	}
}

void QGraphicsItem_StackBefore(void* ptr, void* sibling)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(sibling))) {
			static_cast<QGraphicsObject*>(ptr)->stackBefore(static_cast<QGraphicsObject*>(sibling));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(sibling))) {
			static_cast<QGraphicsObject*>(ptr)->stackBefore(static_cast<QGraphicsWidget*>(sibling));
		} else {
			static_cast<QGraphicsObject*>(ptr)->stackBefore(static_cast<QGraphicsItem*>(sibling));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(sibling))) {
			static_cast<QGraphicsWidget*>(ptr)->stackBefore(static_cast<QGraphicsObject*>(sibling));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(sibling))) {
			static_cast<QGraphicsWidget*>(ptr)->stackBefore(static_cast<QGraphicsWidget*>(sibling));
		} else {
			static_cast<QGraphicsWidget*>(ptr)->stackBefore(static_cast<QGraphicsItem*>(sibling));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(sibling))) {
			static_cast<QGraphicsItem*>(ptr)->stackBefore(static_cast<QGraphicsObject*>(sibling));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(sibling))) {
			static_cast<QGraphicsItem*>(ptr)->stackBefore(static_cast<QGraphicsWidget*>(sibling));
		} else {
			static_cast<QGraphicsItem*>(ptr)->stackBefore(static_cast<QGraphicsItem*>(sibling));
		}
	}
}

void* QGraphicsItem_ToGraphicsObject(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->toGraphicsObject();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->toGraphicsObject();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->toGraphicsObject();
	}
}

void* QGraphicsItem_ToGraphicsObject2(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return const_cast<QGraphicsObject*>(static_cast<QGraphicsObject*>(ptr)->toGraphicsObject());
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return const_cast<QGraphicsObject*>(static_cast<QGraphicsWidget*>(ptr)->toGraphicsObject());
	} else {
		return const_cast<QGraphicsObject*>(static_cast<QGraphicsItem*>(ptr)->toGraphicsObject());
	}
}

struct QtWidgets_PackedString QGraphicsItem_ToolTip(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QByteArray* t7daf65 = new QByteArray(static_cast<QGraphicsObject*>(ptr)->toolTip().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t7daf65->prepend("WHITESPACE").constData()+10), t7daf65->size()-10, t7daf65 }; });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QByteArray* t7daf65 = new QByteArray(static_cast<QGraphicsWidget*>(ptr)->toolTip().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t7daf65->prepend("WHITESPACE").constData()+10), t7daf65->size()-10, t7daf65 }; });
	} else {
		return ({ QByteArray* t7daf65 = new QByteArray(static_cast<QGraphicsItem*>(ptr)->toolTip().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t7daf65->prepend("WHITESPACE").constData()+10), t7daf65->size()-10, t7daf65 }; });
	}
}

void* QGraphicsItem_TopLevelItem(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->topLevelItem();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->topLevelItem();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->topLevelItem();
	}
}

void* QGraphicsItem_TopLevelWidget(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->topLevelWidget();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->topLevelWidget();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->topLevelWidget();
	}
}

void* QGraphicsItem_Transform(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QTransform(static_cast<QGraphicsObject*>(ptr)->transform());
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QTransform(static_cast<QGraphicsWidget*>(ptr)->transform());
	} else {
		return new QTransform(static_cast<QGraphicsItem*>(ptr)->transform());
	}
}

void* QGraphicsItem_TransformOriginPoint(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->transformOriginPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->transformOriginPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->transformOriginPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
	}
}

struct QtWidgets_PackedList QGraphicsItem_Transformations(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QGraphicsTransform *>* tmpValueda467b = new QList<QGraphicsTransform *>(static_cast<QGraphicsObject*>(ptr)->transformations()); QtWidgets_PackedList { tmpValueda467b, tmpValueda467b->size() }; });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QList<QGraphicsTransform *>* tmpValueda467b = new QList<QGraphicsTransform *>(static_cast<QGraphicsWidget*>(ptr)->transformations()); QtWidgets_PackedList { tmpValueda467b, tmpValueda467b->size() }; });
	} else {
		return ({ QList<QGraphicsTransform *>* tmpValueda467b = new QList<QGraphicsTransform *>(static_cast<QGraphicsItem*>(ptr)->transformations()); QtWidgets_PackedList { tmpValueda467b, tmpValueda467b->size() }; });
	}
}

int QGraphicsItem_Type(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->type();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->type();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->type();
	}
}

int QGraphicsItem_TypeDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::type();
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::type();
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::type();
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::type();
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::type();
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::type();
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::type();
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::type();
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::type();
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::type();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::type();
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::type();
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::type();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::type();
	}
}

void QGraphicsItem_UngrabKeyboard(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->ungrabKeyboard();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->ungrabKeyboard();
	} else {
		static_cast<QGraphicsItem*>(ptr)->ungrabKeyboard();
	}
}

void QGraphicsItem_UngrabMouse(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->ungrabMouse();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->ungrabMouse();
	} else {
		static_cast<QGraphicsItem*>(ptr)->ungrabMouse();
	}
}

void QGraphicsItem_UnsetCursor(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->unsetCursor();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->unsetCursor();
	} else {
		static_cast<QGraphicsItem*>(ptr)->unsetCursor();
	}
}

void QGraphicsItem_Update(void* ptr, void* rect)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->update(*static_cast<QRectF*>(rect));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->update(*static_cast<QRectF*>(rect));
	} else {
		static_cast<QGraphicsItem*>(ptr)->update(*static_cast<QRectF*>(rect));
	}
}

void QGraphicsItem_Update2(void* ptr, double x, double y, double width, double height)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->update(x, y, width, height);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->update(x, y, width, height);
	} else {
		static_cast<QGraphicsItem*>(ptr)->update(x, y, width, height);
	}
}

void QGraphicsItem_WheelEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	}
}

void QGraphicsItem_WheelEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsItemGroup*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else if (dynamic_cast<QGraphicsPixmapItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else if (dynamic_cast<QGraphicsLineItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else if (dynamic_cast<QGraphicsSimpleTextItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else if (dynamic_cast<QGraphicsPolygonItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else if (dynamic_cast<QGraphicsEllipseItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else if (dynamic_cast<QGraphicsRectItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else if (dynamic_cast<QGraphicsPathItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else if (dynamic_cast<QAbstractGraphicsShapeItem*>(static_cast<QGraphicsItem*>(ptr))) {
		static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	} else {
		static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
	}
}

void* QGraphicsItem_Window(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->window();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->window();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->window();
	}
}

double QGraphicsItem_X(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->x();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->x();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->x();
	}
}

double QGraphicsItem_Y(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->y();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->y();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->y();
	}
}

double QGraphicsItem_ZValue(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsObject*>(ptr)->zValue();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->zValue();
	} else {
		return static_cast<QGraphicsItem*>(ptr)->zValue();
	}
}

void QGraphicsItem_DestroyQGraphicsItem(void* ptr)
{
	static_cast<QGraphicsItem*>(ptr)->~QGraphicsItem();
}

void QGraphicsItem_DestroyQGraphicsItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QGraphicsItem___childItems_atList(void* ptr, int i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	} else {
		return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	}
}

void QGraphicsItem___childItems_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
		}
	}
}

void* QGraphicsItem___childItems_newList(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QList<QGraphicsItem *>();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QList<QGraphicsItem *>();
	} else {
		return new QList<QGraphicsItem *>();
	}
}

void* QGraphicsItem___children_atList(void* ptr, int i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	} else {
		return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	}
}

void QGraphicsItem___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
		}
	}
}

void* QGraphicsItem___children_newList(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QList<QGraphicsItem *>();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QList<QGraphicsItem *>();
	} else {
		return new QList<QGraphicsItem *>();
	}
}

void* QGraphicsItem___collidingItems_atList(void* ptr, int i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	} else {
		return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	}
}

void QGraphicsItem___collidingItems_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else {
			static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
		}
	}
}

void* QGraphicsItem___collidingItems_newList(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QList<QGraphicsItem *>();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QList<QGraphicsItem *>();
	} else {
		return new QList<QGraphicsItem *>();
	}
}

void* QGraphicsItem___setTransformations_transformations_atList(void* ptr, int i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({QGraphicsTransform * tmp = static_cast<QList<QGraphicsTransform *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsTransform *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsTransform *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({QGraphicsTransform * tmp = static_cast<QList<QGraphicsTransform *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsTransform *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsTransform *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	} else {
		return ({QGraphicsTransform * tmp = static_cast<QList<QGraphicsTransform *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsTransform *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsTransform *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	}
}

void QGraphicsItem___setTransformations_transformations_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QList<QGraphicsTransform *>*>(ptr)->append(static_cast<QGraphicsTransform*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QList<QGraphicsTransform *>*>(ptr)->append(static_cast<QGraphicsTransform*>(i));
	} else {
		static_cast<QList<QGraphicsTransform *>*>(ptr)->append(static_cast<QGraphicsTransform*>(i));
	}
}

void* QGraphicsItem___setTransformations_transformations_newList(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QList<QGraphicsTransform *>();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QList<QGraphicsTransform *>();
	} else {
		return new QList<QGraphicsTransform *>();
	}
}

void* QGraphicsItem___transformations_atList(void* ptr, int i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return ({QGraphicsTransform * tmp = static_cast<QList<QGraphicsTransform *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsTransform *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsTransform *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({QGraphicsTransform * tmp = static_cast<QList<QGraphicsTransform *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsTransform *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsTransform *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	} else {
		return ({QGraphicsTransform * tmp = static_cast<QList<QGraphicsTransform *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsTransform *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsTransform *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	}
}

void QGraphicsItem___transformations_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		static_cast<QList<QGraphicsTransform *>*>(ptr)->append(static_cast<QGraphicsTransform*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QList<QGraphicsTransform *>*>(ptr)->append(static_cast<QGraphicsTransform*>(i));
	} else {
		static_cast<QList<QGraphicsTransform *>*>(ptr)->append(static_cast<QGraphicsTransform*>(i));
	}
}

void* QGraphicsItem___transformations_newList(void* ptr)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(ptr))) {
		return new QList<QGraphicsTransform *>();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QList<QGraphicsTransform *>();
	} else {
		return new QList<QGraphicsTransform *>();
	}
}

class MyQGraphicsItemAnimation: public QGraphicsItemAnimation
{
public:
	MyQGraphicsItemAnimation(QObject *parent = Q_NULLPTR) : QGraphicsItemAnimation(parent) {QGraphicsItemAnimation_QGraphicsItemAnimation_QRegisterMetaType();};
	void afterAnimationStep(qreal step) { callbackQGraphicsItemAnimation_AfterAnimationStep(this, step); };
	void beforeAnimationStep(qreal step) { callbackQGraphicsItemAnimation_BeforeAnimationStep(this, step); };
	void setStep(qreal step) { callbackQGraphicsItemAnimation_SetStep(this, step); };
	 ~MyQGraphicsItemAnimation() { callbackQGraphicsItemAnimation_DestroyQGraphicsItemAnimation(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsItemAnimation_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsItemAnimation_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsItemAnimation_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsItemAnimation_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsItemAnimation_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsItemAnimation_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsItemAnimation_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsItemAnimation_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsItemAnimation_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsItemAnimation_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsItemAnimation_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsItemAnimation*)
Q_DECLARE_METATYPE(MyQGraphicsItemAnimation*)

int QGraphicsItemAnimation_QGraphicsItemAnimation_QRegisterMetaType(){qRegisterMetaType<QGraphicsItemAnimation*>(); return qRegisterMetaType<MyQGraphicsItemAnimation*>();}

void* QGraphicsItemAnimation_NewQGraphicsItemAnimation(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemAnimation(static_cast<QWindow*>(parent));
	} else {
		return new MyQGraphicsItemAnimation(static_cast<QObject*>(parent));
	}
}

void QGraphicsItemAnimation_AfterAnimationStep(void* ptr, double step)
{
	static_cast<QGraphicsItemAnimation*>(ptr)->afterAnimationStep(step);
}

void QGraphicsItemAnimation_AfterAnimationStepDefault(void* ptr, double step)
{
		static_cast<QGraphicsItemAnimation*>(ptr)->QGraphicsItemAnimation::afterAnimationStep(step);
}

void QGraphicsItemAnimation_BeforeAnimationStep(void* ptr, double step)
{
	static_cast<QGraphicsItemAnimation*>(ptr)->beforeAnimationStep(step);
}

void QGraphicsItemAnimation_BeforeAnimationStepDefault(void* ptr, double step)
{
		static_cast<QGraphicsItemAnimation*>(ptr)->QGraphicsItemAnimation::beforeAnimationStep(step);
}

void QGraphicsItemAnimation_Clear(void* ptr)
{
	static_cast<QGraphicsItemAnimation*>(ptr)->clear();
}

double QGraphicsItemAnimation_HorizontalScaleAt(void* ptr, double step)
{
	return static_cast<QGraphicsItemAnimation*>(ptr)->horizontalScaleAt(step);
}

double QGraphicsItemAnimation_HorizontalShearAt(void* ptr, double step)
{
	return static_cast<QGraphicsItemAnimation*>(ptr)->horizontalShearAt(step);
}

void* QGraphicsItemAnimation_Item(void* ptr)
{
	return static_cast<QGraphicsItemAnimation*>(ptr)->item();
}

void* QGraphicsItemAnimation_MatrixAt(void* ptr, double step)
{
	return new QMatrix(static_cast<QGraphicsItemAnimation*>(ptr)->matrixAt(step));
}

void* QGraphicsItemAnimation_PosAt(void* ptr, double step)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItemAnimation*>(ptr)->posAt(step); new QPointF(tmpValue.x(), tmpValue.y()); });
}

double QGraphicsItemAnimation_RotationAt(void* ptr, double step)
{
	return static_cast<QGraphicsItemAnimation*>(ptr)->rotationAt(step);
}

void QGraphicsItemAnimation_SetItem(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsItemAnimation*>(ptr)->setItem(static_cast<QGraphicsObject*>(item));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsItemAnimation*>(ptr)->setItem(static_cast<QGraphicsWidget*>(item));
	} else {
		static_cast<QGraphicsItemAnimation*>(ptr)->setItem(static_cast<QGraphicsItem*>(item));
	}
}

void QGraphicsItemAnimation_SetPosAt(void* ptr, double step, void* point)
{
	static_cast<QGraphicsItemAnimation*>(ptr)->setPosAt(step, *static_cast<QPointF*>(point));
}

void QGraphicsItemAnimation_SetRotationAt(void* ptr, double step, double angle)
{
	static_cast<QGraphicsItemAnimation*>(ptr)->setRotationAt(step, angle);
}

void QGraphicsItemAnimation_SetScaleAt(void* ptr, double step, double sx, double sy)
{
	static_cast<QGraphicsItemAnimation*>(ptr)->setScaleAt(step, sx, sy);
}

void QGraphicsItemAnimation_SetShearAt(void* ptr, double step, double sh, double sv)
{
	static_cast<QGraphicsItemAnimation*>(ptr)->setShearAt(step, sh, sv);
}

void QGraphicsItemAnimation_SetStep(void* ptr, double step)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsItemAnimation*>(ptr), "setStep", Q_ARG(qreal, step));
}

void QGraphicsItemAnimation_SetStepDefault(void* ptr, double step)
{
		static_cast<QGraphicsItemAnimation*>(ptr)->QGraphicsItemAnimation::setStep(step);
}

void QGraphicsItemAnimation_SetTimeLine(void* ptr, void* timeLine)
{
	static_cast<QGraphicsItemAnimation*>(ptr)->setTimeLine(static_cast<QTimeLine*>(timeLine));
}

void QGraphicsItemAnimation_SetTranslationAt(void* ptr, double step, double dx, double dy)
{
	static_cast<QGraphicsItemAnimation*>(ptr)->setTranslationAt(step, dx, dy);
}

void* QGraphicsItemAnimation_TimeLine(void* ptr)
{
	return static_cast<QGraphicsItemAnimation*>(ptr)->timeLine();
}

double QGraphicsItemAnimation_VerticalScaleAt(void* ptr, double step)
{
	return static_cast<QGraphicsItemAnimation*>(ptr)->verticalScaleAt(step);
}

double QGraphicsItemAnimation_VerticalShearAt(void* ptr, double step)
{
	return static_cast<QGraphicsItemAnimation*>(ptr)->verticalShearAt(step);
}

double QGraphicsItemAnimation_XTranslationAt(void* ptr, double step)
{
	return static_cast<QGraphicsItemAnimation*>(ptr)->xTranslationAt(step);
}

double QGraphicsItemAnimation_YTranslationAt(void* ptr, double step)
{
	return static_cast<QGraphicsItemAnimation*>(ptr)->yTranslationAt(step);
}

void QGraphicsItemAnimation_DestroyQGraphicsItemAnimation(void* ptr)
{
	static_cast<QGraphicsItemAnimation*>(ptr)->~QGraphicsItemAnimation();
}

void QGraphicsItemAnimation_DestroyQGraphicsItemAnimationDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QGraphicsItemAnimation___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsItemAnimation___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QGraphicsItemAnimation___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QGraphicsItemAnimation___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsItemAnimation___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QGraphicsItemAnimation___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsItemAnimation___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

void QGraphicsItemAnimation_DeleteLaterDefault(void* ptr)
{
		static_cast<QGraphicsItemAnimation*>(ptr)->QGraphicsItemAnimation::deleteLater();
}

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

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

char QGraphicsItemAnimation_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsItemAnimation*>(ptr)->QGraphicsItemAnimation::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsItemAnimation*>(ptr)->QGraphicsItemAnimation::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsItemAnimation*>(ptr)->QGraphicsItemAnimation::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsItemAnimation*>(ptr)->QGraphicsItemAnimation::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QGraphicsItemAnimation*>(ptr)->QGraphicsItemAnimation::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQGraphicsItemGroup: public QGraphicsItemGroup
{
public:
	MyQGraphicsItemGroup(QGraphicsItem *parent = Q_NULLPTR) : QGraphicsItemGroup(parent) {QGraphicsItemGroup_QGraphicsItemGroup_QRegisterMetaType();};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsItemGroup_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsItemGroup_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	 ~MyQGraphicsItemGroup() { callbackQGraphicsItemGroup_DestroyQGraphicsItemGroup(this); };
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsItemGroup*)
Q_DECLARE_METATYPE(MyQGraphicsItemGroup*)

int QGraphicsItemGroup_QGraphicsItemGroup_QRegisterMetaType(){qRegisterMetaType<QGraphicsItemGroup*>(); return qRegisterMetaType<MyQGraphicsItemGroup*>();}

void* QGraphicsItemGroup_NewQGraphicsItemGroup(void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemGroup(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsItemGroup(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsItemGroup(static_cast<QGraphicsItem*>(parent));
	}
}

void QGraphicsItemGroup_AddToGroup(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsItemGroup*>(ptr)->addToGroup(static_cast<QGraphicsObject*>(item));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsItemGroup*>(ptr)->addToGroup(static_cast<QGraphicsWidget*>(item));
	} else {
		static_cast<QGraphicsItemGroup*>(ptr)->addToGroup(static_cast<QGraphicsItem*>(item));
	}
}

void* QGraphicsItemGroup_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsItemGroup*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsItemGroup_BoundingRectDefault(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsItemGroup_Paint(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsItemGroup*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsItemGroup_PaintDefault(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsItemGroup_RemoveFromGroup(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsItemGroup*>(ptr)->removeFromGroup(static_cast<QGraphicsObject*>(item));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsItemGroup*>(ptr)->removeFromGroup(static_cast<QGraphicsWidget*>(item));
	} else {
		static_cast<QGraphicsItemGroup*>(ptr)->removeFromGroup(static_cast<QGraphicsItem*>(item));
	}
}

void QGraphicsItemGroup_DestroyQGraphicsItemGroup(void* ptr)
{
	static_cast<QGraphicsItemGroup*>(ptr)->~QGraphicsItemGroup();
}

void QGraphicsItemGroup_DestroyQGraphicsItemGroupDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsLayout: public QGraphicsLayout
{
public:
	MyQGraphicsLayout(QGraphicsLayoutItem *parent = Q_NULLPTR) : QGraphicsLayout(parent) {QGraphicsLayout_QGraphicsLayout_QRegisterMetaType();};
	int count() const { return callbackQGraphicsLayout_Count(const_cast<void*>(static_cast<const void*>(this))); };
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsLayoutItem_GetContentsMargins(const_cast<void*>(static_cast<const void*>(this)), *left, *top, *right, *bottom); };
	void invalidate() { callbackQGraphicsLayout_Invalidate(this); };
	QGraphicsLayoutItem * itemAt(int i) const { return static_cast<QGraphicsLayoutItem*>(callbackQGraphicsLayout_ItemAt(const_cast<void*>(static_cast<const void*>(this)), i)); };
	void removeAt(int index) { callbackQGraphicsLayout_RemoveAt(this, index); };
	void updateGeometry() { callbackQGraphicsLayoutItem_UpdateGeometry(this); };
	void widgetEvent(QEvent * e) { callbackQGraphicsLayout_WidgetEvent(this, e); };
	 ~MyQGraphicsLayout() { callbackQGraphicsLayout_DestroyQGraphicsLayout(this); };
	void setGeometry(const QRectF & rect) { callbackQGraphicsLayoutItem_SetGeometry(this, const_cast<QRectF*>(&rect)); };
	QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsLayout_SizeHint(const_cast<void*>(static_cast<const void*>(this)), which, const_cast<QSizeF*>(&constraint))); };
};

Q_DECLARE_METATYPE(QGraphicsLayout*)
Q_DECLARE_METATYPE(MyQGraphicsLayout*)

int QGraphicsLayout_QGraphicsLayout_QRegisterMetaType(){qRegisterMetaType<QGraphicsLayout*>(); return qRegisterMetaType<MyQGraphicsLayout*>();}

void* QGraphicsLayout_NewQGraphicsLayout(void* parent)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsLayout(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsLayout(static_cast<QGraphicsLayoutItem*>(parent));
	}
}

void QGraphicsLayout_Activate(void* ptr)
{
	static_cast<QGraphicsLayout*>(ptr)->activate();
}

void QGraphicsLayout_AddChildLayoutItem(void* ptr, void* layoutItem)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(layoutItem))) {
		static_cast<QGraphicsLayout*>(ptr)->addChildLayoutItem(static_cast<QGraphicsWidget*>(layoutItem));
	} else {
		static_cast<QGraphicsLayout*>(ptr)->addChildLayoutItem(static_cast<QGraphicsLayoutItem*>(layoutItem));
	}
}

int QGraphicsLayout_Count(void* ptr)
{
	return static_cast<QGraphicsLayout*>(ptr)->count();
}

void QGraphicsLayout_Invalidate(void* ptr)
{
	static_cast<QGraphicsLayout*>(ptr)->invalidate();
}

void QGraphicsLayout_InvalidateDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsLinearLayout*>(static_cast<QGraphicsLayout*>(ptr))) {
		static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::invalidate();
	} else if (dynamic_cast<QGraphicsGridLayout*>(static_cast<QGraphicsLayout*>(ptr))) {
		static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::invalidate();
	} else if (dynamic_cast<QGraphicsAnchorLayout*>(static_cast<QGraphicsLayout*>(ptr))) {
		static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::invalidate();
	} else {
		static_cast<QGraphicsLayout*>(ptr)->QGraphicsLayout::invalidate();
	}
}

char QGraphicsLayout_IsActivated(void* ptr)
{
	return static_cast<QGraphicsLayout*>(ptr)->isActivated();
}

void* QGraphicsLayout_ItemAt(void* ptr, int i)
{
	return static_cast<QGraphicsLayout*>(ptr)->itemAt(i);
}

void QGraphicsLayout_RemoveAt(void* ptr, int index)
{
	static_cast<QGraphicsLayout*>(ptr)->removeAt(index);
}

void QGraphicsLayout_SetContentsMargins(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsLayout*>(ptr)->setContentsMargins(left, top, right, bottom);
}

void QGraphicsLayout_WidgetEvent(void* ptr, void* e)
{
	static_cast<QGraphicsLayout*>(ptr)->widgetEvent(static_cast<QEvent*>(e));
}

void QGraphicsLayout_WidgetEventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QGraphicsLinearLayout*>(static_cast<QGraphicsLayout*>(ptr))) {
		static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::widgetEvent(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QGraphicsGridLayout*>(static_cast<QGraphicsLayout*>(ptr))) {
		static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::widgetEvent(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QGraphicsAnchorLayout*>(static_cast<QGraphicsLayout*>(ptr))) {
		static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::widgetEvent(static_cast<QEvent*>(e));
	} else {
		static_cast<QGraphicsLayout*>(ptr)->QGraphicsLayout::widgetEvent(static_cast<QEvent*>(e));
	}
}

void QGraphicsLayout_DestroyQGraphicsLayout(void* ptr)
{
	static_cast<QGraphicsLayout*>(ptr)->~QGraphicsLayout();
}

void QGraphicsLayout_DestroyQGraphicsLayoutDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QGraphicsLayout_SizeHint(void* ptr, long long which, void* constraint)
{
	return ({ QSizeF tmpValue = static_cast<QGraphicsLayout*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsLayout_SizeHintDefault(void* ptr, long long which, void* constraint)
{
	if (dynamic_cast<QGraphicsLinearLayout*>(static_cast<QGraphicsLayout*>(ptr))) {
		return ({ QSizeF tmpValue = static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsGridLayout*>(static_cast<QGraphicsLayout*>(ptr))) {
		return ({ QSizeF tmpValue = static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsAnchorLayout*>(static_cast<QGraphicsLayout*>(ptr))) {
		return ({ QSizeF tmpValue = static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
	} else {
	
	}
}

class MyQGraphicsLayoutItem: public QGraphicsLayoutItem
{
public:
	MyQGraphicsLayoutItem(QGraphicsLayoutItem *parent = Q_NULLPTR, bool isLayout = false) : QGraphicsLayoutItem(parent, isLayout) {QGraphicsLayoutItem_QGraphicsLayoutItem_QRegisterMetaType();};
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsLayoutItem_GetContentsMargins(const_cast<void*>(static_cast<const void*>(this)), *left, *top, *right, *bottom); };
	void setGeometry(const QRectF & rect) { callbackQGraphicsLayoutItem_SetGeometry(this, const_cast<QRectF*>(&rect)); };
	QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsLayoutItem_SizeHint(const_cast<void*>(static_cast<const void*>(this)), which, const_cast<QSizeF*>(&constraint))); };
	void updateGeometry() { callbackQGraphicsLayoutItem_UpdateGeometry(this); };
	 ~MyQGraphicsLayoutItem() { callbackQGraphicsLayoutItem_DestroyQGraphicsLayoutItem(this); };
};

Q_DECLARE_METATYPE(QGraphicsLayoutItem*)
Q_DECLARE_METATYPE(MyQGraphicsLayoutItem*)

int QGraphicsLayoutItem_QGraphicsLayoutItem_QRegisterMetaType(){qRegisterMetaType<QGraphicsLayoutItem*>(); return qRegisterMetaType<MyQGraphicsLayoutItem*>();}

void* QGraphicsLayoutItem_NewQGraphicsLayoutItem(void* parent, char isLayout)
{
	return new MyQGraphicsLayoutItem(static_cast<QGraphicsLayoutItem*>(parent), isLayout != 0);
}

void* QGraphicsLayoutItem_ContentsRect(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->contentsRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsLayoutItem*>(ptr)->contentsRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QGraphicsLayoutItem_EffectiveSizeHint(void* ptr, long long which, void* constraint)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSizeF tmpValue = static_cast<QGraphicsWidget*>(ptr)->effectiveSizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSizeF tmpValue = static_cast<QGraphicsLayoutItem*>(ptr)->effectiveSizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
	}
}

void* QGraphicsLayoutItem_Geometry(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->geometry(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsLayoutItem*>(ptr)->geometry(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void QGraphicsLayoutItem_GetContentsMargins(void* ptr, double left, double top, double right, double bottom)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->getContentsMargins(&left, &top, &right, &bottom);
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->getContentsMargins(&left, &top, &right, &bottom);
	}
}

void QGraphicsLayoutItem_GetContentsMarginsDefault(void* ptr, double left, double top, double right, double bottom)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::getContentsMargins(&left, &top, &right, &bottom);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::getContentsMargins(&left, &top, &right, &bottom);
	} else if (dynamic_cast<QGraphicsLinearLayout*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
		static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::getContentsMargins(&left, &top, &right, &bottom);
	} else if (dynamic_cast<QGraphicsGridLayout*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
		static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::getContentsMargins(&left, &top, &right, &bottom);
	} else if (dynamic_cast<QGraphicsAnchorLayout*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
		static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::getContentsMargins(&left, &top, &right, &bottom);
	} else if (dynamic_cast<QGraphicsLayout*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
		static_cast<QGraphicsLayout*>(ptr)->QGraphicsLayout::getContentsMargins(&left, &top, &right, &bottom);
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->QGraphicsLayoutItem::getContentsMargins(&left, &top, &right, &bottom);
	}
}

void* QGraphicsLayoutItem_GraphicsItem(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->graphicsItem();
	} else {
		return static_cast<QGraphicsLayoutItem*>(ptr)->graphicsItem();
	}
}

char QGraphicsLayoutItem_IsLayout(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isLayout();
	} else {
		return static_cast<QGraphicsLayoutItem*>(ptr)->isLayout();
	}
}

double QGraphicsLayoutItem_MaximumHeight(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->maximumHeight();
	} else {
		return static_cast<QGraphicsLayoutItem*>(ptr)->maximumHeight();
	}
}

void* QGraphicsLayoutItem_MaximumSize(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSizeF tmpValue = static_cast<QGraphicsWidget*>(ptr)->maximumSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSizeF tmpValue = static_cast<QGraphicsLayoutItem*>(ptr)->maximumSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
	}
}

double QGraphicsLayoutItem_MaximumWidth(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->maximumWidth();
	} else {
		return static_cast<QGraphicsLayoutItem*>(ptr)->maximumWidth();
	}
}

double QGraphicsLayoutItem_MinimumHeight(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->minimumHeight();
	} else {
		return static_cast<QGraphicsLayoutItem*>(ptr)->minimumHeight();
	}
}

void* QGraphicsLayoutItem_MinimumSize(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSizeF tmpValue = static_cast<QGraphicsWidget*>(ptr)->minimumSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSizeF tmpValue = static_cast<QGraphicsLayoutItem*>(ptr)->minimumSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
	}
}

double QGraphicsLayoutItem_MinimumWidth(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->minimumWidth();
	} else {
		return static_cast<QGraphicsLayoutItem*>(ptr)->minimumWidth();
	}
}

char QGraphicsLayoutItem_OwnedByLayout(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->ownedByLayout();
	} else {
		return static_cast<QGraphicsLayoutItem*>(ptr)->ownedByLayout();
	}
}

void* QGraphicsLayoutItem_ParentLayoutItem(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->parentLayoutItem();
	} else {
		return static_cast<QGraphicsLayoutItem*>(ptr)->parentLayoutItem();
	}
}

double QGraphicsLayoutItem_PreferredHeight(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->preferredHeight();
	} else {
		return static_cast<QGraphicsLayoutItem*>(ptr)->preferredHeight();
	}
}

void* QGraphicsLayoutItem_PreferredSize(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSizeF tmpValue = static_cast<QGraphicsWidget*>(ptr)->preferredSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSizeF tmpValue = static_cast<QGraphicsLayoutItem*>(ptr)->preferredSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
	}
}

double QGraphicsLayoutItem_PreferredWidth(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->preferredWidth();
	} else {
		return static_cast<QGraphicsLayoutItem*>(ptr)->preferredWidth();
	}
}

void QGraphicsLayoutItem_SetGeometry(void* ptr, void* rect)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setGeometry(*static_cast<QRectF*>(rect));
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setGeometry(*static_cast<QRectF*>(rect));
	}
}

void QGraphicsLayoutItem_SetGeometryDefault(void* ptr, void* rect)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::setGeometry(*static_cast<QRectF*>(rect));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::setGeometry(*static_cast<QRectF*>(rect));
	} else if (dynamic_cast<QGraphicsLinearLayout*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
		static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::setGeometry(*static_cast<QRectF*>(rect));
	} else if (dynamic_cast<QGraphicsGridLayout*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
		static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::setGeometry(*static_cast<QRectF*>(rect));
	} else if (dynamic_cast<QGraphicsAnchorLayout*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
		static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::setGeometry(*static_cast<QRectF*>(rect));
	} else if (dynamic_cast<QGraphicsLayout*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
		static_cast<QGraphicsLayout*>(ptr)->QGraphicsLayout::setGeometry(*static_cast<QRectF*>(rect));
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->QGraphicsLayoutItem::setGeometry(*static_cast<QRectF*>(rect));
	}
}

void QGraphicsLayoutItem_SetGraphicsItem(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			static_cast<QGraphicsWidget*>(ptr)->setGraphicsItem(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			static_cast<QGraphicsWidget*>(ptr)->setGraphicsItem(static_cast<QGraphicsWidget*>(item));
		} else {
			static_cast<QGraphicsWidget*>(ptr)->setGraphicsItem(static_cast<QGraphicsItem*>(item));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
			static_cast<QGraphicsLayoutItem*>(ptr)->setGraphicsItem(static_cast<QGraphicsObject*>(item));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
			static_cast<QGraphicsLayoutItem*>(ptr)->setGraphicsItem(static_cast<QGraphicsWidget*>(item));
		} else {
			static_cast<QGraphicsLayoutItem*>(ptr)->setGraphicsItem(static_cast<QGraphicsItem*>(item));
		}
	}
}

void QGraphicsLayoutItem_SetMaximumHeight(void* ptr, double height)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setMaximumHeight(height);
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setMaximumHeight(height);
	}
}

void QGraphicsLayoutItem_SetMaximumSize(void* ptr, void* size)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setMaximumSize(*static_cast<QSizeF*>(size));
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setMaximumSize(*static_cast<QSizeF*>(size));
	}
}

void QGraphicsLayoutItem_SetMaximumSize2(void* ptr, double w, double h)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setMaximumSize(w, h);
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setMaximumSize(w, h);
	}
}

void QGraphicsLayoutItem_SetMaximumWidth(void* ptr, double width)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setMaximumWidth(width);
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setMaximumWidth(width);
	}
}

void QGraphicsLayoutItem_SetMinimumHeight(void* ptr, double height)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setMinimumHeight(height);
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setMinimumHeight(height);
	}
}

void QGraphicsLayoutItem_SetMinimumSize(void* ptr, void* size)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setMinimumSize(*static_cast<QSizeF*>(size));
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setMinimumSize(*static_cast<QSizeF*>(size));
	}
}

void QGraphicsLayoutItem_SetMinimumSize2(void* ptr, double w, double h)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setMinimumSize(w, h);
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setMinimumSize(w, h);
	}
}

void QGraphicsLayoutItem_SetMinimumWidth(void* ptr, double width)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setMinimumWidth(width);
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setMinimumWidth(width);
	}
}

void QGraphicsLayoutItem_SetOwnedByLayout(void* ptr, char ownership)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setOwnedByLayout(ownership != 0);
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setOwnedByLayout(ownership != 0);
	}
}

void QGraphicsLayoutItem_SetParentLayoutItem(void* ptr, void* parent)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
			static_cast<QGraphicsWidget*>(ptr)->setParentLayoutItem(static_cast<QGraphicsWidget*>(parent));
		} else {
			static_cast<QGraphicsWidget*>(ptr)->setParentLayoutItem(static_cast<QGraphicsLayoutItem*>(parent));
		}
	} else {
		if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
			static_cast<QGraphicsLayoutItem*>(ptr)->setParentLayoutItem(static_cast<QGraphicsWidget*>(parent));
		} else {
			static_cast<QGraphicsLayoutItem*>(ptr)->setParentLayoutItem(static_cast<QGraphicsLayoutItem*>(parent));
		}
	}
}

void QGraphicsLayoutItem_SetPreferredHeight(void* ptr, double height)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setPreferredHeight(height);
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setPreferredHeight(height);
	}
}

void QGraphicsLayoutItem_SetPreferredSize(void* ptr, void* size)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setPreferredSize(*static_cast<QSizeF*>(size));
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setPreferredSize(*static_cast<QSizeF*>(size));
	}
}

void QGraphicsLayoutItem_SetPreferredSize2(void* ptr, double w, double h)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setPreferredSize(w, h);
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setPreferredSize(w, h);
	}
}

void QGraphicsLayoutItem_SetPreferredWidth(void* ptr, double width)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setPreferredWidth(width);
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setPreferredWidth(width);
	}
}

void QGraphicsLayoutItem_SetSizePolicy(void* ptr, void* policy)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setSizePolicy(*static_cast<QSizePolicy*>(policy));
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setSizePolicy(*static_cast<QSizePolicy*>(policy));
	}
}

void QGraphicsLayoutItem_SetSizePolicy2(void* ptr, long long hPolicy, long long vPolicy, long long controlType)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setSizePolicy(static_cast<QSizePolicy::Policy>(hPolicy), static_cast<QSizePolicy::Policy>(vPolicy), static_cast<QSizePolicy::ControlType>(controlType));
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->setSizePolicy(static_cast<QSizePolicy::Policy>(hPolicy), static_cast<QSizePolicy::Policy>(vPolicy), static_cast<QSizePolicy::ControlType>(controlType));
	}
}

void* QGraphicsLayoutItem_SizeHint(void* ptr, long long which, void* constraint)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSizeF tmpValue = static_cast<QGraphicsWidget*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSizeF tmpValue = static_cast<QGraphicsLayoutItem*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
	}
}

void* QGraphicsLayoutItem_SizePolicy(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QSizePolicy(static_cast<QGraphicsWidget*>(ptr)->sizePolicy());
	} else {
		return new QSizePolicy(static_cast<QGraphicsLayoutItem*>(ptr)->sizePolicy());
	}
}

void QGraphicsLayoutItem_UpdateGeometry(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->updateGeometry();
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->updateGeometry();
	}
}

void QGraphicsLayoutItem_UpdateGeometryDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::updateGeometry();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::updateGeometry();
	} else if (dynamic_cast<QGraphicsLinearLayout*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
		static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::updateGeometry();
	} else if (dynamic_cast<QGraphicsGridLayout*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
		static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::updateGeometry();
	} else if (dynamic_cast<QGraphicsAnchorLayout*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
		static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::updateGeometry();
	} else if (dynamic_cast<QGraphicsLayout*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
		static_cast<QGraphicsLayout*>(ptr)->QGraphicsLayout::updateGeometry();
	} else {
		static_cast<QGraphicsLayoutItem*>(ptr)->QGraphicsLayoutItem::updateGeometry();
	}
}

void QGraphicsLayoutItem_DestroyQGraphicsLayoutItem(void* ptr)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->~QGraphicsLayoutItem();
}

void QGraphicsLayoutItem_DestroyQGraphicsLayoutItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsLineItem: public QGraphicsLineItem
{
public:
	MyQGraphicsLineItem(QGraphicsItem *parent = Q_NULLPTR) : QGraphicsLineItem(parent) {QGraphicsLineItem_QGraphicsLineItem_QRegisterMetaType();};
	MyQGraphicsLineItem(const QLineF &line, QGraphicsItem *parent = Q_NULLPTR) : QGraphicsLineItem(line, parent) {QGraphicsLineItem_QGraphicsLineItem_QRegisterMetaType();};
	MyQGraphicsLineItem(qreal x1, qreal y1, qreal x2, qreal y2, QGraphicsItem *parent = Q_NULLPTR) : QGraphicsLineItem(x1, y1, x2, y2, parent) {QGraphicsLineItem_QGraphicsLineItem_QRegisterMetaType();};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsLineItem_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsLineItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	 ~MyQGraphicsLineItem() { callbackQGraphicsLineItem_DestroyQGraphicsLineItem(this); };
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsLineItem*)
Q_DECLARE_METATYPE(MyQGraphicsLineItem*)

int QGraphicsLineItem_QGraphicsLineItem_QRegisterMetaType(){qRegisterMetaType<QGraphicsLineItem*>(); return qRegisterMetaType<MyQGraphicsLineItem*>();}

void* QGraphicsLineItem_NewQGraphicsLineItem(void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsLineItem(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsLineItem(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsLineItem(static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsLineItem_NewQGraphicsLineItem2(void* line, void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsLineItem(*static_cast<QLineF*>(line), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsLineItem(*static_cast<QLineF*>(line), static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsLineItem(*static_cast<QLineF*>(line), static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsLineItem_NewQGraphicsLineItem3(double x1, double y1, double x2, double y2, void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsLineItem(x1, y1, x2, y2, static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsLineItem(x1, y1, x2, y2, static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsLineItem(x1, y1, x2, y2, static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsLineItem_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsLineItem*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsLineItem_BoundingRectDefault(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsLineItem_Line(void* ptr)
{
	return ({ QLineF tmpValue = static_cast<QGraphicsLineItem*>(ptr)->line(); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}

void QGraphicsLineItem_Paint(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsLineItem*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsLineItem_PaintDefault(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void* QGraphicsLineItem_Pen(void* ptr)
{
	return new QPen(static_cast<QGraphicsLineItem*>(ptr)->pen());
}

void QGraphicsLineItem_SetLine(void* ptr, void* line)
{
	static_cast<QGraphicsLineItem*>(ptr)->setLine(*static_cast<QLineF*>(line));
}

void QGraphicsLineItem_SetLine2(void* ptr, double x1, double y1, double x2, double y2)
{
	static_cast<QGraphicsLineItem*>(ptr)->setLine(x1, y1, x2, y2);
}

void QGraphicsLineItem_SetPen(void* ptr, void* pen)
{
	static_cast<QGraphicsLineItem*>(ptr)->setPen(*static_cast<QPen*>(pen));
}

void QGraphicsLineItem_DestroyQGraphicsLineItem(void* ptr)
{
	static_cast<QGraphicsLineItem*>(ptr)->~QGraphicsLineItem();
}

void QGraphicsLineItem_DestroyQGraphicsLineItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsLinearLayout: public QGraphicsLinearLayout
{
public:
	MyQGraphicsLinearLayout(QGraphicsLayoutItem *parent = Q_NULLPTR) : QGraphicsLinearLayout(parent) {QGraphicsLinearLayout_QGraphicsLinearLayout_QRegisterMetaType();};
	MyQGraphicsLinearLayout(Qt::Orientation orientation, QGraphicsLayoutItem *parent = Q_NULLPTR) : QGraphicsLinearLayout(orientation, parent) {QGraphicsLinearLayout_QGraphicsLinearLayout_QRegisterMetaType();};
	int count() const { return callbackQGraphicsLinearLayout_Count(const_cast<void*>(static_cast<const void*>(this))); };
	void invalidate() { callbackQGraphicsLayout_Invalidate(this); };
	QGraphicsLayoutItem * itemAt(int index) const { return static_cast<QGraphicsLayoutItem*>(callbackQGraphicsLinearLayout_ItemAt(const_cast<void*>(static_cast<const void*>(this)), index)); };
	void removeAt(int index) { callbackQGraphicsLinearLayout_RemoveAt(this, index); };
	void setGeometry(const QRectF & rect) { callbackQGraphicsLayoutItem_SetGeometry(this, const_cast<QRectF*>(&rect)); };
	QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsLinearLayout_SizeHint(const_cast<void*>(static_cast<const void*>(this)), which, const_cast<QSizeF*>(&constraint))); };
	 ~MyQGraphicsLinearLayout() { callbackQGraphicsLinearLayout_DestroyQGraphicsLinearLayout(this); };
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsLayoutItem_GetContentsMargins(const_cast<void*>(static_cast<const void*>(this)), *left, *top, *right, *bottom); };
	void updateGeometry() { callbackQGraphicsLayoutItem_UpdateGeometry(this); };
	void widgetEvent(QEvent * e) { callbackQGraphicsLayout_WidgetEvent(this, e); };
};

Q_DECLARE_METATYPE(QGraphicsLinearLayout*)
Q_DECLARE_METATYPE(MyQGraphicsLinearLayout*)

int QGraphicsLinearLayout_QGraphicsLinearLayout_QRegisterMetaType(){qRegisterMetaType<QGraphicsLinearLayout*>(); return qRegisterMetaType<MyQGraphicsLinearLayout*>();}

void* QGraphicsLinearLayout_NewQGraphicsLinearLayout(void* parent)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsLinearLayout(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsLinearLayout(static_cast<QGraphicsLayoutItem*>(parent));
	}
}

void* QGraphicsLinearLayout_NewQGraphicsLinearLayout2(long long orientation, void* parent)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsLinearLayout(static_cast<Qt::Orientation>(orientation), static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsLinearLayout(static_cast<Qt::Orientation>(orientation), static_cast<QGraphicsLayoutItem*>(parent));
	}
}

void QGraphicsLinearLayout_AddItem(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsLinearLayout*>(ptr)->addItem(static_cast<QGraphicsWidget*>(item));
	} else {
		static_cast<QGraphicsLinearLayout*>(ptr)->addItem(static_cast<QGraphicsLayoutItem*>(item));
	}
}

void QGraphicsLinearLayout_AddStretch(void* ptr, int stretch)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->addStretch(stretch);
}

long long QGraphicsLinearLayout_Alignment(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		return static_cast<QGraphicsLinearLayout*>(ptr)->alignment(static_cast<QGraphicsWidget*>(item));
	} else {
		return static_cast<QGraphicsLinearLayout*>(ptr)->alignment(static_cast<QGraphicsLayoutItem*>(item));
	}
}

int QGraphicsLinearLayout_Count(void* ptr)
{
	return static_cast<QGraphicsLinearLayout*>(ptr)->count();
}

int QGraphicsLinearLayout_CountDefault(void* ptr)
{
		return static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::count();
}

void QGraphicsLinearLayout_InsertItem(void* ptr, int index, void* item)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsLinearLayout*>(ptr)->insertItem(index, static_cast<QGraphicsWidget*>(item));
	} else {
		static_cast<QGraphicsLinearLayout*>(ptr)->insertItem(index, static_cast<QGraphicsLayoutItem*>(item));
	}
}

void QGraphicsLinearLayout_InsertStretch(void* ptr, int index, int stretch)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->insertStretch(index, stretch);
}

void* QGraphicsLinearLayout_ItemAt(void* ptr, int index)
{
	return static_cast<QGraphicsLinearLayout*>(ptr)->itemAt(index);
}

void* QGraphicsLinearLayout_ItemAtDefault(void* ptr, int index)
{
		return static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::itemAt(index);
}

double QGraphicsLinearLayout_ItemSpacing(void* ptr, int index)
{
	return static_cast<QGraphicsLinearLayout*>(ptr)->itemSpacing(index);
}

long long QGraphicsLinearLayout_Orientation(void* ptr)
{
	return static_cast<QGraphicsLinearLayout*>(ptr)->orientation();
}

void QGraphicsLinearLayout_RemoveAt(void* ptr, int index)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->removeAt(index);
}

void QGraphicsLinearLayout_RemoveAtDefault(void* ptr, int index)
{
		static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::removeAt(index);
}

void QGraphicsLinearLayout_RemoveItem(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsLinearLayout*>(ptr)->removeItem(static_cast<QGraphicsWidget*>(item));
	} else {
		static_cast<QGraphicsLinearLayout*>(ptr)->removeItem(static_cast<QGraphicsLayoutItem*>(item));
	}
}

void QGraphicsLinearLayout_SetAlignment(void* ptr, void* item, long long alignment)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsLinearLayout*>(ptr)->setAlignment(static_cast<QGraphicsWidget*>(item), static_cast<Qt::AlignmentFlag>(alignment));
	} else {
		static_cast<QGraphicsLinearLayout*>(ptr)->setAlignment(static_cast<QGraphicsLayoutItem*>(item), static_cast<Qt::AlignmentFlag>(alignment));
	}
}

void QGraphicsLinearLayout_SetItemSpacing(void* ptr, int index, double spacing)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->setItemSpacing(index, spacing);
}

void QGraphicsLinearLayout_SetOrientation(void* ptr, long long orientation)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->setOrientation(static_cast<Qt::Orientation>(orientation));
}

void QGraphicsLinearLayout_SetSpacing(void* ptr, double spacing)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->setSpacing(spacing);
}

void QGraphicsLinearLayout_SetStretchFactor(void* ptr, void* item, int stretch)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsLinearLayout*>(ptr)->setStretchFactor(static_cast<QGraphicsWidget*>(item), stretch);
	} else {
		static_cast<QGraphicsLinearLayout*>(ptr)->setStretchFactor(static_cast<QGraphicsLayoutItem*>(item), stretch);
	}
}

void* QGraphicsLinearLayout_SizeHint(void* ptr, long long which, void* constraint)
{
	return ({ QSizeF tmpValue = static_cast<QGraphicsLinearLayout*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsLinearLayout_SizeHintDefault(void* ptr, long long which, void* constraint)
{
		return ({ QSizeF tmpValue = static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

double QGraphicsLinearLayout_Spacing(void* ptr)
{
	return static_cast<QGraphicsLinearLayout*>(ptr)->spacing();
}

int QGraphicsLinearLayout_StretchFactor(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		return static_cast<QGraphicsLinearLayout*>(ptr)->stretchFactor(static_cast<QGraphicsWidget*>(item));
	} else {
		return static_cast<QGraphicsLinearLayout*>(ptr)->stretchFactor(static_cast<QGraphicsLayoutItem*>(item));
	}
}

void QGraphicsLinearLayout_DestroyQGraphicsLinearLayout(void* ptr)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->~QGraphicsLinearLayout();
}

void QGraphicsLinearLayout_DestroyQGraphicsLinearLayoutDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsObject: public QGraphicsObject
{
public:
	MyQGraphicsObject(QGraphicsItem *parent = Q_NULLPTR) : QGraphicsObject(parent) {QGraphicsObject_QGraphicsObject_QRegisterMetaType();};
	void Signal_EnabledChanged() { callbackQGraphicsObject_EnabledChanged(this); };
	bool event(QEvent * ev) { return callbackQGraphicsObject_Event(this, ev) != 0; };
	void Signal_OpacityChanged() { callbackQGraphicsObject_OpacityChanged(this); };
	void Signal_ParentChanged() { callbackQGraphicsObject_ParentChanged(this); };
	void Signal_RotationChanged() { callbackQGraphicsObject_RotationChanged(this); };
	void Signal_ScaleChanged() { callbackQGraphicsObject_ScaleChanged(this); };
	void updateMicroFocus() { callbackQGraphicsObject_UpdateMicroFocus(this); };
	void Signal_VisibleChanged() { callbackQGraphicsObject_VisibleChanged(this); };
	void Signal_XChanged() { callbackQGraphicsObject_XChanged(this); };
	void Signal_YChanged() { callbackQGraphicsObject_YChanged(this); };
	void Signal_ZChanged() { callbackQGraphicsObject_ZChanged(this); };
	 ~MyQGraphicsObject() { callbackQGraphicsObject_DestroyQGraphicsObject(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsObject_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsObject_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsObject_TimerEvent(this, event); };
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsObject_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsObject_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsObject*)
Q_DECLARE_METATYPE(MyQGraphicsObject*)

int QGraphicsObject_QGraphicsObject_QRegisterMetaType(){qRegisterMetaType<QGraphicsObject*>(); return qRegisterMetaType<MyQGraphicsObject*>();}

void* QGraphicsObject_NewQGraphicsObject(void* parent)
{
	return new MyQGraphicsObject(static_cast<QGraphicsItem*>(parent));
}

void QGraphicsObject_ConnectEnabledChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::enabledChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_EnabledChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsObject_DisconnectEnabledChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::enabledChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_EnabledChanged));
}

void QGraphicsObject_EnabledChanged(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->enabledChanged();
	} else {
		static_cast<QGraphicsObject*>(ptr)->enabledChanged();
	}
}

char QGraphicsObject_Event(void* ptr, void* ev)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->event(static_cast<QEvent*>(ev));
	} else {
		return static_cast<QGraphicsObject*>(ptr)->event(static_cast<QEvent*>(ev));
	}
}

char QGraphicsObject_EventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::event(static_cast<QEvent*>(ev));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::event(static_cast<QEvent*>(ev));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::event(static_cast<QEvent*>(ev));
	} else {
		return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::event(static_cast<QEvent*>(ev));
	}
}

void QGraphicsObject_GrabGesture(void* ptr, long long gesture, long long flags)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->grabGesture(static_cast<Qt::GestureType>(gesture), static_cast<Qt::GestureFlag>(flags));
	} else {
		static_cast<QGraphicsObject*>(ptr)->grabGesture(static_cast<Qt::GestureType>(gesture), static_cast<Qt::GestureFlag>(flags));
	}
}

void QGraphicsObject_ConnectOpacityChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::opacityChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_OpacityChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsObject_DisconnectOpacityChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::opacityChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_OpacityChanged));
}

void QGraphicsObject_OpacityChanged(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->opacityChanged();
	} else {
		static_cast<QGraphicsObject*>(ptr)->opacityChanged();
	}
}

void QGraphicsObject_ConnectParentChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::parentChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_ParentChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsObject_DisconnectParentChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::parentChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_ParentChanged));
}

void QGraphicsObject_ParentChanged(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->parentChanged();
	} else {
		static_cast<QGraphicsObject*>(ptr)->parentChanged();
	}
}

void QGraphicsObject_ConnectRotationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::rotationChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_RotationChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsObject_DisconnectRotationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::rotationChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_RotationChanged));
}

void QGraphicsObject_RotationChanged(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->rotationChanged();
	} else {
		static_cast<QGraphicsObject*>(ptr)->rotationChanged();
	}
}

void QGraphicsObject_ConnectScaleChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::scaleChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_ScaleChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsObject_DisconnectScaleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::scaleChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_ScaleChanged));
}

void QGraphicsObject_ScaleChanged(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->scaleChanged();
	} else {
		static_cast<QGraphicsObject*>(ptr)->scaleChanged();
	}
}

void QGraphicsObject_UngrabGesture(void* ptr, long long gesture)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->ungrabGesture(static_cast<Qt::GestureType>(gesture));
	} else {
		static_cast<QGraphicsObject*>(ptr)->ungrabGesture(static_cast<Qt::GestureType>(gesture));
	}
}

void QGraphicsObject_UpdateMicroFocus(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QGraphicsWidget*>(ptr), "updateMicroFocus");
	} else {
		QMetaObject::invokeMethod(static_cast<QGraphicsObject*>(ptr), "updateMicroFocus");
	}
}

void QGraphicsObject_UpdateMicroFocusDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::updateMicroFocus();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::updateMicroFocus();
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::updateMicroFocus();
	} else {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::updateMicroFocus();
	}
}

void QGraphicsObject_ConnectVisibleChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::visibleChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_VisibleChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsObject_DisconnectVisibleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::visibleChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_VisibleChanged));
}

void QGraphicsObject_VisibleChanged(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->visibleChanged();
	} else {
		static_cast<QGraphicsObject*>(ptr)->visibleChanged();
	}
}

void QGraphicsObject_ConnectXChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::xChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_XChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsObject_DisconnectXChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::xChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_XChanged));
}

void QGraphicsObject_XChanged(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->xChanged();
	} else {
		static_cast<QGraphicsObject*>(ptr)->xChanged();
	}
}

void QGraphicsObject_ConnectYChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::yChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_YChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsObject_DisconnectYChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::yChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_YChanged));
}

void QGraphicsObject_YChanged(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->yChanged();
	} else {
		static_cast<QGraphicsObject*>(ptr)->yChanged();
	}
}

void QGraphicsObject_ConnectZChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::zChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_ZChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsObject_DisconnectZChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::zChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_ZChanged));
}

void QGraphicsObject_ZChanged(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->zChanged();
	} else {
		static_cast<QGraphicsObject*>(ptr)->zChanged();
	}
}

void QGraphicsObject_DestroyQGraphicsObject(void* ptr)
{
	static_cast<QGraphicsObject*>(ptr)->~QGraphicsObject();
}

void QGraphicsObject_DestroyQGraphicsObjectDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QGraphicsObject_Parent(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->parent();
	} else {
		return static_cast<QGraphicsObject*>(ptr)->parent();
	}
}

void QGraphicsObject_SetParent(void* ptr, void* parent)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
			static_cast<QGraphicsWidget*>(ptr)->setParent(static_cast<QGraphicsWidget*>(parent));
		} else {
			static_cast<QGraphicsWidget*>(ptr)->setParent(static_cast<QGraphicsObject*>(parent));
		}
	} else {
		if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
			static_cast<QGraphicsObject*>(ptr)->setParent(static_cast<QGraphicsWidget*>(parent));
		} else {
			static_cast<QGraphicsObject*>(ptr)->setParent(static_cast<QGraphicsObject*>(parent));
		}
	}
}

double QGraphicsObject_Opacity(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->opacity();
	} else {
		return static_cast<QGraphicsObject*>(ptr)->opacity();
	}
}

void QGraphicsObject_SetOpacity(void* ptr, double opacity)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setOpacity(opacity);
	} else {
		static_cast<QGraphicsObject*>(ptr)->setOpacity(opacity);
	}
}

char QGraphicsObject_IsEnabled(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isEnabled();
	} else {
		return static_cast<QGraphicsObject*>(ptr)->isEnabled();
	}
}

void QGraphicsObject_SetEnabled(void* ptr, char enabled)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setEnabled(enabled != 0);
	} else {
		static_cast<QGraphicsObject*>(ptr)->setEnabled(enabled != 0);
	}
}

char QGraphicsObject_IsVisible(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->isVisible();
	} else {
		return static_cast<QGraphicsObject*>(ptr)->isVisible();
	}
}

void QGraphicsObject_SetVisible(void* ptr, char visible)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setVisible(visible != 0);
	} else {
		static_cast<QGraphicsObject*>(ptr)->setVisible(visible != 0);
	}
}

void* QGraphicsObject_Pos(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->pos(); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->pos(); new QPointF(tmpValue.x(), tmpValue.y()); });
	}
}

void QGraphicsObject_SetPos(void* ptr, void* pos)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setPos(*static_cast<QPointF*>(pos));
	} else {
		static_cast<QGraphicsObject*>(ptr)->setPos(*static_cast<QPointF*>(pos));
	}
}

double QGraphicsObject_X(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->x();
	} else {
		return static_cast<QGraphicsObject*>(ptr)->x();
	}
}

void QGraphicsObject_SetX(void* ptr, double x)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setX(x);
	} else {
		static_cast<QGraphicsObject*>(ptr)->setX(x);
	}
}

double QGraphicsObject_Y(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->y();
	} else {
		return static_cast<QGraphicsObject*>(ptr)->y();
	}
}

void QGraphicsObject_SetY(void* ptr, double y)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setY(y);
	} else {
		static_cast<QGraphicsObject*>(ptr)->setY(y);
	}
}

double QGraphicsObject_ZValue(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->zValue();
	} else {
		return static_cast<QGraphicsObject*>(ptr)->zValue();
	}
}

void QGraphicsObject_SetZValue(void* ptr, double z)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setZValue(z);
	} else {
		static_cast<QGraphicsObject*>(ptr)->setZValue(z);
	}
}

double QGraphicsObject_Rotation(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->rotation();
	} else {
		return static_cast<QGraphicsObject*>(ptr)->rotation();
	}
}

void QGraphicsObject_SetRotation(void* ptr, double rotation)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setRotation(rotation);
	} else {
		static_cast<QGraphicsObject*>(ptr)->setRotation(rotation);
	}
}

double QGraphicsObject_Scale(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->scale();
	} else {
		return static_cast<QGraphicsObject*>(ptr)->scale();
	}
}

void QGraphicsObject_SetScale(void* ptr, double scale)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setScale(scale);
	} else {
		static_cast<QGraphicsObject*>(ptr)->setScale(scale);
	}
}

void* QGraphicsObject_TransformOriginPoint(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QPointF tmpValue = static_cast<QGraphicsWidget*>(ptr)->transformOriginPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPointF tmpValue = static_cast<QGraphicsObject*>(ptr)->transformOriginPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
	}
}

void QGraphicsObject_SetTransformOriginPoint(void* ptr, void* transformOriginPoint)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setTransformOriginPoint(*static_cast<QPointF*>(transformOriginPoint));
	} else {
		static_cast<QGraphicsObject*>(ptr)->setTransformOriginPoint(*static_cast<QPointF*>(transformOriginPoint));
	}
}

void* QGraphicsObject_GraphicsEffect(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsWidget*>(ptr)->graphicsEffect();
	} else {
		return static_cast<QGraphicsObject*>(ptr)->graphicsEffect();
	}
}

void QGraphicsObject_SetGraphicsEffect(void* ptr, void* effect)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->setGraphicsEffect(static_cast<QGraphicsEffect*>(effect));
	} else {
		static_cast<QGraphicsObject*>(ptr)->setGraphicsEffect(static_cast<QGraphicsEffect*>(effect));
	}
}

void* QGraphicsObject___children_atList(void* ptr, int i)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	} else {
		return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
	}
}

void QGraphicsObject___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
		} else {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
		} else {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
		}
	}
}

void* QGraphicsObject___children_newList(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QList<QObject *>();
	} else {
		return new QList<QObject *>();
	}
}

void* QGraphicsObject___dynamicPropertyNames_atList(void* ptr, int i)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
	} else {
		return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
	}
}

void QGraphicsObject___dynamicPropertyNames_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsWidget*>(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* QGraphicsObject___dynamicPropertyNames_newList(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QList<QByteArray>();
	} else {
		return new QList<QByteArray>();
	}
}

void* QGraphicsObject___findChildren_atList(void* ptr, int i)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
	} else {
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
	}
}

void QGraphicsObject___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
		} else {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
		} else {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
		}
	}
}

void* QGraphicsObject___findChildren_newList(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QList<QObject*>();
	} else {
		return new QList<QObject*>();
	}
}

void* QGraphicsObject___findChildren_atList3(void* ptr, int i)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
	} else {
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
	}
}

void QGraphicsObject___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
		} else {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
		} else {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
		}
	}
}

void* QGraphicsObject___findChildren_newList3(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return new QList<QObject*>();
	} else {
		return new QList<QObject*>();
	}
}

void QGraphicsObject_ChildEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QGraphicsObject*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
	}
}

void QGraphicsObject_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QGraphicsObject_ConnectNotify(void* ptr, void* sign)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QGraphicsObject*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QGraphicsObject_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QGraphicsObject_CustomEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QGraphicsObject*>(ptr)->customEvent(static_cast<QEvent*>(event));
	}
}

void QGraphicsObject_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::customEvent(static_cast<QEvent*>(event));
	}
}

void QGraphicsObject_DeleteLater(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QGraphicsWidget*>(ptr), "deleteLater");
	} else {
		QMetaObject::invokeMethod(static_cast<QGraphicsObject*>(ptr), "deleteLater");
	}
}

void QGraphicsObject_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::deleteLater();
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::deleteLater();
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::deleteLater();
	} else {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::deleteLater();
	}
}

void QGraphicsObject_DisconnectNotify(void* ptr, void* sign)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QGraphicsObject*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QGraphicsObject_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

char QGraphicsObject_EventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsWidget*>(ptr)->eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsWidget*>(ptr)->eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsWidget*>(ptr)->eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsWidget*>(ptr)->eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsObject*>(ptr)->eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsObject*>(ptr)->eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsObject*>(ptr)->eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsObject*>(ptr)->eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsObject*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

char QGraphicsObject_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void* QGraphicsObject_MetaObject(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QGraphicsWidget*>(ptr)->metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QGraphicsObject*>(ptr)->metaObject());
	}
}

void* QGraphicsObject_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::metaObject());
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::metaObject());
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::metaObject());
	}
}

void QGraphicsObject_TimerEvent(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QGraphicsObject*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
	}
}

void QGraphicsObject_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

void* QGraphicsObject_BoundingRect(void* ptr)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
	
	}
}

void* QGraphicsObject_BoundingRectDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
	
	}
}

void QGraphicsObject_Paint(void* ptr, void* painter, void* option, void* widget)
{
	if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	} else {
	
	}
}

void QGraphicsObject_PaintDefault(void* ptr, void* painter, void* option, void* widget)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QGraphicsTextItem*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	} else {
	
	}
}

class MyQGraphicsOpacityEffect: public QGraphicsOpacityEffect
{
public:
	MyQGraphicsOpacityEffect(QObject *parent = Q_NULLPTR) : QGraphicsOpacityEffect(parent) {QGraphicsOpacityEffect_QGraphicsOpacityEffect_QRegisterMetaType();};
	void draw(QPainter * painter) { callbackQGraphicsOpacityEffect_Draw(this, painter); };
	void Signal_OpacityChanged(qreal opacity) { callbackQGraphicsOpacityEffect_OpacityChanged(this, opacity); };
	void Signal_OpacityMaskChanged(const QBrush & mask) { callbackQGraphicsOpacityEffect_OpacityMaskChanged(this, const_cast<QBrush*>(&mask)); };
	void setOpacity(qreal opacity) { callbackQGraphicsOpacityEffect_SetOpacity(this, opacity); };
	void setOpacityMask(const QBrush & mask) { callbackQGraphicsOpacityEffect_SetOpacityMask(this, const_cast<QBrush*>(&mask)); };
	 ~MyQGraphicsOpacityEffect() { callbackQGraphicsOpacityEffect_DestroyQGraphicsOpacityEffect(this); };
	QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsEffect_BoundingRectFor(const_cast<void*>(static_cast<const void*>(this)), const_cast<QRectF*>(&rect))); };
	void Signal_EnabledChanged(bool enabled) { callbackQGraphicsEffect_EnabledChanged(this, enabled); };
	void setEnabled(bool enable) { callbackQGraphicsEffect_SetEnabled(this, enable); };
	void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsEffect_SourceChanged(this, flags); };
	void update() { callbackQGraphicsEffect_Update(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsEffect_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsEffect_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsEffect_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsEffect_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsEffect_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsEffect_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsEffect_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsEffect_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsEffect_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsEffect_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsEffect_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsOpacityEffect*)
Q_DECLARE_METATYPE(MyQGraphicsOpacityEffect*)

int QGraphicsOpacityEffect_QGraphicsOpacityEffect_QRegisterMetaType(){qRegisterMetaType<QGraphicsOpacityEffect*>(); return qRegisterMetaType<MyQGraphicsOpacityEffect*>();}

void* QGraphicsOpacityEffect_NewQGraphicsOpacityEffect(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsOpacityEffect(static_cast<QWindow*>(parent));
	} else {
		return new MyQGraphicsOpacityEffect(static_cast<QObject*>(parent));
	}
}

void QGraphicsOpacityEffect_Draw(void* ptr, void* painter)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->draw(static_cast<QPainter*>(painter));
}

void QGraphicsOpacityEffect_DrawDefault(void* ptr, void* painter)
{
		static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::draw(static_cast<QPainter*>(painter));
}

double QGraphicsOpacityEffect_Opacity(void* ptr)
{
	return static_cast<QGraphicsOpacityEffect*>(ptr)->opacity();
}

void QGraphicsOpacityEffect_ConnectOpacityChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsOpacityEffect*>(ptr), static_cast<void (QGraphicsOpacityEffect::*)(qreal)>(&QGraphicsOpacityEffect::opacityChanged), static_cast<MyQGraphicsOpacityEffect*>(ptr), static_cast<void (MyQGraphicsOpacityEffect::*)(qreal)>(&MyQGraphicsOpacityEffect::Signal_OpacityChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsOpacityEffect_DisconnectOpacityChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsOpacityEffect*>(ptr), static_cast<void (QGraphicsOpacityEffect::*)(qreal)>(&QGraphicsOpacityEffect::opacityChanged), static_cast<MyQGraphicsOpacityEffect*>(ptr), static_cast<void (MyQGraphicsOpacityEffect::*)(qreal)>(&MyQGraphicsOpacityEffect::Signal_OpacityChanged));
}

void QGraphicsOpacityEffect_OpacityChanged(void* ptr, double opacity)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->opacityChanged(opacity);
}

void* QGraphicsOpacityEffect_OpacityMask(void* ptr)
{
	return new QBrush(static_cast<QGraphicsOpacityEffect*>(ptr)->opacityMask());
}

void QGraphicsOpacityEffect_ConnectOpacityMaskChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsOpacityEffect*>(ptr), static_cast<void (QGraphicsOpacityEffect::*)(const QBrush &)>(&QGraphicsOpacityEffect::opacityMaskChanged), static_cast<MyQGraphicsOpacityEffect*>(ptr), static_cast<void (MyQGraphicsOpacityEffect::*)(const QBrush &)>(&MyQGraphicsOpacityEffect::Signal_OpacityMaskChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsOpacityEffect_DisconnectOpacityMaskChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsOpacityEffect*>(ptr), static_cast<void (QGraphicsOpacityEffect::*)(const QBrush &)>(&QGraphicsOpacityEffect::opacityMaskChanged), static_cast<MyQGraphicsOpacityEffect*>(ptr), static_cast<void (MyQGraphicsOpacityEffect::*)(const QBrush &)>(&MyQGraphicsOpacityEffect::Signal_OpacityMaskChanged));
}

void QGraphicsOpacityEffect_OpacityMaskChanged(void* ptr, void* mask)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->opacityMaskChanged(*static_cast<QBrush*>(mask));
}

void QGraphicsOpacityEffect_SetOpacity(void* ptr, double opacity)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsOpacityEffect*>(ptr), "setOpacity", Q_ARG(qreal, opacity));
}

void QGraphicsOpacityEffect_SetOpacityDefault(void* ptr, double opacity)
{
		static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::setOpacity(opacity);
}

void QGraphicsOpacityEffect_SetOpacityMask(void* ptr, void* mask)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsOpacityEffect*>(ptr), "setOpacityMask", Q_ARG(const QBrush, *static_cast<QBrush*>(mask)));
}

void QGraphicsOpacityEffect_SetOpacityMaskDefault(void* ptr, void* mask)
{
		static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::setOpacityMask(*static_cast<QBrush*>(mask));
}

void QGraphicsOpacityEffect_DestroyQGraphicsOpacityEffect(void* ptr)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->~QGraphicsOpacityEffect();
}

void QGraphicsOpacityEffect_DestroyQGraphicsOpacityEffectDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsPathItem: public QGraphicsPathItem
{
public:
	MyQGraphicsPathItem(QGraphicsItem *parent = Q_NULLPTR) : QGraphicsPathItem(parent) {QGraphicsPathItem_QGraphicsPathItem_QRegisterMetaType();};
	MyQGraphicsPathItem(const QPainterPath &path, QGraphicsItem *parent = Q_NULLPTR) : QGraphicsPathItem(path, parent) {QGraphicsPathItem_QGraphicsPathItem_QRegisterMetaType();};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsPathItem_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsPathItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	 ~MyQGraphicsPathItem() { callbackQGraphicsPathItem_DestroyQGraphicsPathItem(this); };
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsPathItem*)
Q_DECLARE_METATYPE(MyQGraphicsPathItem*)

int QGraphicsPathItem_QGraphicsPathItem_QRegisterMetaType(){qRegisterMetaType<QGraphicsPathItem*>(); return qRegisterMetaType<MyQGraphicsPathItem*>();}

void* QGraphicsPathItem_NewQGraphicsPathItem(void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsPathItem(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsPathItem(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsPathItem(static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsPathItem_NewQGraphicsPathItem2(void* path, void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsPathItem(*static_cast<QPainterPath*>(path), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsPathItem(*static_cast<QPainterPath*>(path), static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsPathItem(*static_cast<QPainterPath*>(path), static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsPathItem_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsPathItem*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsPathItem_BoundingRectDefault(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsPathItem_Paint(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsPathItem*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsPathItem_PaintDefault(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void* QGraphicsPathItem_Path(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsPathItem*>(ptr)->path());
}

void QGraphicsPathItem_SetPath(void* ptr, void* path)
{
	static_cast<QGraphicsPathItem*>(ptr)->setPath(*static_cast<QPainterPath*>(path));
}

void QGraphicsPathItem_DestroyQGraphicsPathItem(void* ptr)
{
	static_cast<QGraphicsPathItem*>(ptr)->~QGraphicsPathItem();
}

void QGraphicsPathItem_DestroyQGraphicsPathItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsPixmapItem: public QGraphicsPixmapItem
{
public:
	MyQGraphicsPixmapItem(QGraphicsItem *parent = Q_NULLPTR) : QGraphicsPixmapItem(parent) {QGraphicsPixmapItem_QGraphicsPixmapItem_QRegisterMetaType();};
	MyQGraphicsPixmapItem(const QPixmap &pixmap, QGraphicsItem *parent = Q_NULLPTR) : QGraphicsPixmapItem(pixmap, parent) {QGraphicsPixmapItem_QGraphicsPixmapItem_QRegisterMetaType();};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsPixmapItem_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsPixmapItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	 ~MyQGraphicsPixmapItem() { callbackQGraphicsPixmapItem_DestroyQGraphicsPixmapItem(this); };
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsPixmapItem*)
Q_DECLARE_METATYPE(MyQGraphicsPixmapItem*)

int QGraphicsPixmapItem_QGraphicsPixmapItem_QRegisterMetaType(){qRegisterMetaType<QGraphicsPixmapItem*>(); return qRegisterMetaType<MyQGraphicsPixmapItem*>();}

void* QGraphicsPixmapItem_NewQGraphicsPixmapItem(void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsPixmapItem(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsPixmapItem(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsPixmapItem(static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsPixmapItem_NewQGraphicsPixmapItem2(void* pixmap, void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsPixmapItem(*static_cast<QPixmap*>(pixmap), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsPixmapItem(*static_cast<QPixmap*>(pixmap), static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsPixmapItem(*static_cast<QPixmap*>(pixmap), static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsPixmapItem_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsPixmapItem*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsPixmapItem_BoundingRectDefault(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsPixmapItem_Offset(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsPixmapItem*>(ptr)->offset(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QGraphicsPixmapItem_Paint(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsPixmapItem*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsPixmapItem_PaintDefault(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

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

void QGraphicsPixmapItem_SetOffset(void* ptr, void* offset)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->setOffset(*static_cast<QPointF*>(offset));
}

void QGraphicsPixmapItem_SetOffset2(void* ptr, double x, double y)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->setOffset(x, y);
}

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

void QGraphicsPixmapItem_SetShapeMode(void* ptr, long long mode)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->setShapeMode(static_cast<QGraphicsPixmapItem::ShapeMode>(mode));
}

void QGraphicsPixmapItem_SetTransformationMode(void* ptr, long long mode)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->setTransformationMode(static_cast<Qt::TransformationMode>(mode));
}

long long QGraphicsPixmapItem_ShapeMode(void* ptr)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->shapeMode();
}

long long QGraphicsPixmapItem_TransformationMode(void* ptr)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->transformationMode();
}

void QGraphicsPixmapItem_DestroyQGraphicsPixmapItem(void* ptr)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->~QGraphicsPixmapItem();
}

void QGraphicsPixmapItem_DestroyQGraphicsPixmapItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsPolygonItem: public QGraphicsPolygonItem
{
public:
	MyQGraphicsPolygonItem(QGraphicsItem *parent = Q_NULLPTR) : QGraphicsPolygonItem(parent) {QGraphicsPolygonItem_QGraphicsPolygonItem_QRegisterMetaType();};
	MyQGraphicsPolygonItem(const QPolygonF &polygon, QGraphicsItem *parent = Q_NULLPTR) : QGraphicsPolygonItem(polygon, parent) {QGraphicsPolygonItem_QGraphicsPolygonItem_QRegisterMetaType();};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsPolygonItem_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsPolygonItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	 ~MyQGraphicsPolygonItem() { callbackQGraphicsPolygonItem_DestroyQGraphicsPolygonItem(this); };
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsPolygonItem*)
Q_DECLARE_METATYPE(MyQGraphicsPolygonItem*)

int QGraphicsPolygonItem_QGraphicsPolygonItem_QRegisterMetaType(){qRegisterMetaType<QGraphicsPolygonItem*>(); return qRegisterMetaType<MyQGraphicsPolygonItem*>();}

void* QGraphicsPolygonItem_NewQGraphicsPolygonItem(void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsPolygonItem(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsPolygonItem(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsPolygonItem(static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsPolygonItem_NewQGraphicsPolygonItem2(void* polygon, void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsPolygonItem(*static_cast<QPolygonF*>(polygon), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsPolygonItem(*static_cast<QPolygonF*>(polygon), static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsPolygonItem(*static_cast<QPolygonF*>(polygon), static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsPolygonItem_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsPolygonItem*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsPolygonItem_BoundingRectDefault(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

long long QGraphicsPolygonItem_FillRule(void* ptr)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->fillRule();
}

void QGraphicsPolygonItem_Paint(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsPolygonItem*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsPolygonItem_PaintDefault(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void* QGraphicsPolygonItem_Polygon(void* ptr)
{
	return new QPolygonF(static_cast<QGraphicsPolygonItem*>(ptr)->polygon());
}

void QGraphicsPolygonItem_SetFillRule(void* ptr, long long rule)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->setFillRule(static_cast<Qt::FillRule>(rule));
}

void QGraphicsPolygonItem_SetPolygon(void* ptr, void* polygon)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->setPolygon(*static_cast<QPolygonF*>(polygon));
}

void QGraphicsPolygonItem_DestroyQGraphicsPolygonItem(void* ptr)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->~QGraphicsPolygonItem();
}

void QGraphicsPolygonItem_DestroyQGraphicsPolygonItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsProxyWidget: public QGraphicsProxyWidget
{
public:
	MyQGraphicsProxyWidget(QGraphicsItem *parent = Q_NULLPTR, Qt::WindowFlags wFlags = Qt::WindowFlags()) : QGraphicsProxyWidget(parent, wFlags) {QGraphicsProxyWidget_QGraphicsProxyWidget_QRegisterMetaType();};
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	bool event(QEvent * event) { return callbackQGraphicsObject_Event(this, event) != 0; };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQGraphicsObject_EventFilter(this, object, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQGraphicsWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void grabMouseEvent(QEvent * event) { callbackQGraphicsWidget_GrabMouseEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQGraphicsWidget_HideEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	QGraphicsProxyWidget * newProxyWidget(const QWidget * child) { return static_cast<QGraphicsProxyWidget*>(callbackQGraphicsProxyWidget_NewProxyWidget(this, const_cast<QWidget*>(child))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsWidget_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	void resizeEvent(QGraphicsSceneResizeEvent * event) { callbackQGraphicsWidget_ResizeEvent(this, event); };
	void setGeometry(const QRectF & rect) { callbackQGraphicsLayoutItem_SetGeometry(this, const_cast<QRectF*>(&rect)); };
	void showEvent(QShowEvent * event) { callbackQGraphicsWidget_ShowEvent(this, event); };
	QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)), which, const_cast<QSizeF*>(&constraint))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	void ungrabMouseEvent(QEvent * event) { callbackQGraphicsWidget_UngrabMouseEvent(this, event); };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
	 ~MyQGraphicsProxyWidget() { callbackQGraphicsProxyWidget_DestroyQGraphicsProxyWidget(this); };
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsWidget_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	void changeEvent(QEvent * event) { callbackQGraphicsWidget_ChangeEvent(this, event); };
	bool close() { return callbackQGraphicsWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQGraphicsWidget_CloseEvent(this, event); };
	void Signal_GeometryChanged() { callbackQGraphicsWidget_GeometryChanged(this); };
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsLayoutItem_GetContentsMargins(const_cast<void*>(static_cast<const void*>(this)), *left, *top, *right, *bottom); };
	void grabKeyboardEvent(QEvent * event) { callbackQGraphicsWidget_GrabKeyboardEvent(this, event); };
	void initStyleOption(QStyleOption * option) const { callbackQGraphicsWidget_InitStyleOption(const_cast<void*>(static_cast<const void*>(this)), option); };
	void Signal_LayoutChanged() { callbackQGraphicsWidget_LayoutChanged(this); };
	void moveEvent(QGraphicsSceneMoveEvent * event) { callbackQGraphicsWidget_MoveEvent(this, event); };
	void paintWindowFrame(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsWidget_PaintWindowFrame(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	void polishEvent() { callbackQGraphicsWidget_PolishEvent(this); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	void ungrabKeyboardEvent(QEvent * event) { callbackQGraphicsWidget_UngrabKeyboardEvent(this, event); };
	void updateGeometry() { callbackQGraphicsLayoutItem_UpdateGeometry(this); };
	bool windowFrameEvent(QEvent * event) { return callbackQGraphicsWidget_WindowFrameEvent(this, event) != 0; };
	Qt::WindowFrameSection windowFrameSectionAt(const QPointF & pos) const { return static_cast<Qt::WindowFrameSection>(callbackQGraphicsWidget_WindowFrameSectionAt(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&pos))); };
	void Signal_EnabledChanged() { callbackQGraphicsObject_EnabledChanged(this); };
	void Signal_OpacityChanged() { callbackQGraphicsObject_OpacityChanged(this); };
	void Signal_ParentChanged() { callbackQGraphicsObject_ParentChanged(this); };
	void Signal_RotationChanged() { callbackQGraphicsObject_RotationChanged(this); };
	void Signal_ScaleChanged() { callbackQGraphicsObject_ScaleChanged(this); };
	void updateMicroFocus() { callbackQGraphicsObject_UpdateMicroFocus(this); };
	void Signal_VisibleChanged() { callbackQGraphicsObject_VisibleChanged(this); };
	void Signal_XChanged() { callbackQGraphicsObject_XChanged(this); };
	void Signal_YChanged() { callbackQGraphicsObject_YChanged(this); };
	void Signal_ZChanged() { callbackQGraphicsObject_ZChanged(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsObject_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsObject_TimerEvent(this, event); };
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
};

Q_DECLARE_METATYPE(QGraphicsProxyWidget*)
Q_DECLARE_METATYPE(MyQGraphicsProxyWidget*)

int QGraphicsProxyWidget_QGraphicsProxyWidget_QRegisterMetaType(){qRegisterMetaType<QGraphicsProxyWidget*>(); return qRegisterMetaType<MyQGraphicsProxyWidget*>();}

void* QGraphicsProxyWidget_NewQGraphicsProxyWidget(void* parent, long long wFlags)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsProxyWidget(static_cast<QGraphicsObject*>(parent), static_cast<Qt::WindowType>(wFlags));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsProxyWidget(static_cast<QGraphicsWidget*>(parent), static_cast<Qt::WindowType>(wFlags));
	} else {
		return new MyQGraphicsProxyWidget(static_cast<QGraphicsItem*>(parent), static_cast<Qt::WindowType>(wFlags));
	}
}

void* QGraphicsProxyWidget_CreateProxyForChildWidget(void* ptr, void* child)
{
		return static_cast<QGraphicsProxyWidget*>(ptr)->createProxyForChildWidget(static_cast<QWidget*>(child));
}

void* QGraphicsProxyWidget_NewProxyWidget(void* ptr, void* child)
{
		QGraphicsProxyWidget* returnArg;
	QMetaObject::invokeMethod(static_cast<QGraphicsProxyWidget*>(ptr), "newProxyWidget", Q_RETURN_ARG(QGraphicsProxyWidget*, returnArg), Q_ARG(const QWidget*, static_cast<QWidget*>(child)));
	return returnArg;
}

void* QGraphicsProxyWidget_NewProxyWidgetDefault(void* ptr, void* child)
{
		return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::newProxyWidget(static_cast<QWidget*>(child));
}

void QGraphicsProxyWidget_SetWidget(void* ptr, void* widget)
{
		static_cast<QGraphicsProxyWidget*>(ptr)->setWidget(static_cast<QWidget*>(widget));
}

void* QGraphicsProxyWidget_SubWidgetRect(void* ptr, void* widget)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsProxyWidget*>(ptr)->subWidgetRect(static_cast<QWidget*>(widget)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsProxyWidget_Widget(void* ptr)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->widget();
}

void QGraphicsProxyWidget_DestroyQGraphicsProxyWidget(void* ptr)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->~QGraphicsProxyWidget();
}

void QGraphicsProxyWidget_DestroyQGraphicsProxyWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsRectItem: public QGraphicsRectItem
{
public:
	MyQGraphicsRectItem(QGraphicsItem *parent = Q_NULLPTR) : QGraphicsRectItem(parent) {QGraphicsRectItem_QGraphicsRectItem_QRegisterMetaType();};
	MyQGraphicsRectItem(const QRectF &rect, QGraphicsItem *parent = Q_NULLPTR) : QGraphicsRectItem(rect, parent) {QGraphicsRectItem_QGraphicsRectItem_QRegisterMetaType();};
	MyQGraphicsRectItem(qreal x, qreal y, qreal width, qreal height, QGraphicsItem *parent = Q_NULLPTR) : QGraphicsRectItem(x, y, width, height, parent) {QGraphicsRectItem_QGraphicsRectItem_QRegisterMetaType();};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsRectItem_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsRectItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	 ~MyQGraphicsRectItem() { callbackQGraphicsRectItem_DestroyQGraphicsRectItem(this); };
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsRectItem*)
Q_DECLARE_METATYPE(MyQGraphicsRectItem*)

int QGraphicsRectItem_QGraphicsRectItem_QRegisterMetaType(){qRegisterMetaType<QGraphicsRectItem*>(); return qRegisterMetaType<MyQGraphicsRectItem*>();}

void* QGraphicsRectItem_NewQGraphicsRectItem(void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRectItem(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRectItem(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsRectItem(static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsRectItem_NewQGraphicsRectItem2(void* rect, void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRectItem(*static_cast<QRectF*>(rect), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRectItem(*static_cast<QRectF*>(rect), static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsRectItem(*static_cast<QRectF*>(rect), static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsRectItem_NewQGraphicsRectItem3(double x, double y, double width, double height, void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRectItem(x, y, width, height, static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRectItem(x, y, width, height, static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsRectItem(x, y, width, height, static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsRectItem_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsRectItem*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsRectItem_BoundingRectDefault(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsRectItem_Paint(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsRectItem*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsRectItem_PaintDefault(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void* QGraphicsRectItem_Rect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsRectItem*>(ptr)->rect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsRectItem_SetRect(void* ptr, void* rectangle)
{
	static_cast<QGraphicsRectItem*>(ptr)->setRect(*static_cast<QRectF*>(rectangle));
}

void QGraphicsRectItem_SetRect2(void* ptr, double x, double y, double width, double height)
{
	static_cast<QGraphicsRectItem*>(ptr)->setRect(x, y, width, height);
}

void QGraphicsRectItem_DestroyQGraphicsRectItem(void* ptr)
{
	static_cast<QGraphicsRectItem*>(ptr)->~QGraphicsRectItem();
}

void QGraphicsRectItem_DestroyQGraphicsRectItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsRotation: public QGraphicsRotation
{
public:
	MyQGraphicsRotation(QObject *parent = Q_NULLPTR) : QGraphicsRotation(parent) {QGraphicsRotation_QGraphicsRotation_QRegisterMetaType();};
	void Signal_AngleChanged() { callbackQGraphicsRotation_AngleChanged(this); };
	void applyTo(QMatrix4x4 * matrix) const { callbackQGraphicsRotation_ApplyTo(const_cast<void*>(static_cast<const void*>(this)), matrix); };
	void Signal_AxisChanged() { callbackQGraphicsRotation_AxisChanged(this); };
	void Signal_OriginChanged() { callbackQGraphicsRotation_OriginChanged(this); };
	 ~MyQGraphicsRotation() { callbackQGraphicsRotation_DestroyQGraphicsRotation(this); };
	void update() { callbackQGraphicsTransform_Update(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsTransform_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsTransform_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsTransform_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsTransform_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsTransform_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsTransform_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsTransform_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsTransform_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsTransform_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsTransform_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsTransform_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsRotation*)
Q_DECLARE_METATYPE(MyQGraphicsRotation*)

int QGraphicsRotation_QGraphicsRotation_QRegisterMetaType(){qRegisterMetaType<QGraphicsRotation*>(); return qRegisterMetaType<MyQGraphicsRotation*>();}

void* QGraphicsRotation_NewQGraphicsRotation(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsRotation(static_cast<QWindow*>(parent));
	} else {
		return new MyQGraphicsRotation(static_cast<QObject*>(parent));
	}
}

double QGraphicsRotation_Angle(void* ptr)
{
	return static_cast<QGraphicsRotation*>(ptr)->angle();
}

void QGraphicsRotation_ConnectAngleChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsRotation*>(ptr), static_cast<void (QGraphicsRotation::*)()>(&QGraphicsRotation::angleChanged), static_cast<MyQGraphicsRotation*>(ptr), static_cast<void (MyQGraphicsRotation::*)()>(&MyQGraphicsRotation::Signal_AngleChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsRotation_DisconnectAngleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsRotation*>(ptr), static_cast<void (QGraphicsRotation::*)()>(&QGraphicsRotation::angleChanged), static_cast<MyQGraphicsRotation*>(ptr), static_cast<void (MyQGraphicsRotation::*)()>(&MyQGraphicsRotation::Signal_AngleChanged));
}

void QGraphicsRotation_AngleChanged(void* ptr)
{
	static_cast<QGraphicsRotation*>(ptr)->angleChanged();
}

void QGraphicsRotation_ApplyTo(void* ptr, void* matrix)
{
	static_cast<QGraphicsRotation*>(ptr)->applyTo(static_cast<QMatrix4x4*>(matrix));
}

void QGraphicsRotation_ApplyToDefault(void* ptr, void* matrix)
{
		static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::applyTo(static_cast<QMatrix4x4*>(matrix));
}

void* QGraphicsRotation_Axis(void* ptr)
{
	return new QVector3D(static_cast<QGraphicsRotation*>(ptr)->axis());
}

void QGraphicsRotation_ConnectAxisChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsRotation*>(ptr), static_cast<void (QGraphicsRotation::*)()>(&QGraphicsRotation::axisChanged), static_cast<MyQGraphicsRotation*>(ptr), static_cast<void (MyQGraphicsRotation::*)()>(&MyQGraphicsRotation::Signal_AxisChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsRotation_DisconnectAxisChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsRotation*>(ptr), static_cast<void (QGraphicsRotation::*)()>(&QGraphicsRotation::axisChanged), static_cast<MyQGraphicsRotation*>(ptr), static_cast<void (MyQGraphicsRotation::*)()>(&MyQGraphicsRotation::Signal_AxisChanged));
}

void QGraphicsRotation_AxisChanged(void* ptr)
{
	static_cast<QGraphicsRotation*>(ptr)->axisChanged();
}

void* QGraphicsRotation_Origin(void* ptr)
{
	return new QVector3D(static_cast<QGraphicsRotation*>(ptr)->origin());
}

void QGraphicsRotation_ConnectOriginChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsRotation*>(ptr), static_cast<void (QGraphicsRotation::*)()>(&QGraphicsRotation::originChanged), static_cast<MyQGraphicsRotation*>(ptr), static_cast<void (MyQGraphicsRotation::*)()>(&MyQGraphicsRotation::Signal_OriginChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsRotation_DisconnectOriginChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsRotation*>(ptr), static_cast<void (QGraphicsRotation::*)()>(&QGraphicsRotation::originChanged), static_cast<MyQGraphicsRotation*>(ptr), static_cast<void (MyQGraphicsRotation::*)()>(&MyQGraphicsRotation::Signal_OriginChanged));
}

void QGraphicsRotation_OriginChanged(void* ptr)
{
	static_cast<QGraphicsRotation*>(ptr)->originChanged();
}

void QGraphicsRotation_SetAngle(void* ptr, double vqr)
{
	static_cast<QGraphicsRotation*>(ptr)->setAngle(vqr);
}

void QGraphicsRotation_SetAxis(void* ptr, void* axis)
{
	static_cast<QGraphicsRotation*>(ptr)->setAxis(*static_cast<QVector3D*>(axis));
}

void QGraphicsRotation_SetAxis2(void* ptr, long long axis)
{
	static_cast<QGraphicsRotation*>(ptr)->setAxis(static_cast<Qt::Axis>(axis));
}

void QGraphicsRotation_SetOrigin(void* ptr, void* point)
{
	static_cast<QGraphicsRotation*>(ptr)->setOrigin(*static_cast<QVector3D*>(point));
}

void QGraphicsRotation_DestroyQGraphicsRotation(void* ptr)
{
	static_cast<QGraphicsRotation*>(ptr)->~QGraphicsRotation();
}

void QGraphicsRotation_DestroyQGraphicsRotationDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsScale: public QGraphicsScale
{
public:
	MyQGraphicsScale(QObject *parent = Q_NULLPTR) : QGraphicsScale(parent) {QGraphicsScale_QGraphicsScale_QRegisterMetaType();};
	void applyTo(QMatrix4x4 * matrix) const { callbackQGraphicsScale_ApplyTo(const_cast<void*>(static_cast<const void*>(this)), matrix); };
	void Signal_OriginChanged() { callbackQGraphicsScale_OriginChanged(this); };
	void Signal_ScaleChanged() { callbackQGraphicsScale_ScaleChanged(this); };
	void Signal_XScaleChanged() { callbackQGraphicsScale_XScaleChanged(this); };
	void Signal_YScaleChanged() { callbackQGraphicsScale_YScaleChanged(this); };
	void Signal_ZScaleChanged() { callbackQGraphicsScale_ZScaleChanged(this); };
	 ~MyQGraphicsScale() { callbackQGraphicsScale_DestroyQGraphicsScale(this); };
	void update() { callbackQGraphicsTransform_Update(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsTransform_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsTransform_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsTransform_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsTransform_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsTransform_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsTransform_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsTransform_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsTransform_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsTransform_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsTransform_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsTransform_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsScale*)
Q_DECLARE_METATYPE(MyQGraphicsScale*)

int QGraphicsScale_QGraphicsScale_QRegisterMetaType(){qRegisterMetaType<QGraphicsScale*>(); return qRegisterMetaType<MyQGraphicsScale*>();}

void* QGraphicsScale_NewQGraphicsScale(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScale(static_cast<QWindow*>(parent));
	} else {
		return new MyQGraphicsScale(static_cast<QObject*>(parent));
	}
}

void QGraphicsScale_ApplyTo(void* ptr, void* matrix)
{
	static_cast<QGraphicsScale*>(ptr)->applyTo(static_cast<QMatrix4x4*>(matrix));
}

void QGraphicsScale_ApplyToDefault(void* ptr, void* matrix)
{
		static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::applyTo(static_cast<QMatrix4x4*>(matrix));
}

void* QGraphicsScale_Origin(void* ptr)
{
	return new QVector3D(static_cast<QGraphicsScale*>(ptr)->origin());
}

void QGraphicsScale_ConnectOriginChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::originChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_OriginChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsScale_DisconnectOriginChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::originChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_OriginChanged));
}

void QGraphicsScale_OriginChanged(void* ptr)
{
	static_cast<QGraphicsScale*>(ptr)->originChanged();
}

void QGraphicsScale_ConnectScaleChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::scaleChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_ScaleChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsScale_DisconnectScaleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::scaleChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_ScaleChanged));
}

void QGraphicsScale_ScaleChanged(void* ptr)
{
	static_cast<QGraphicsScale*>(ptr)->scaleChanged();
}

void QGraphicsScale_SetOrigin(void* ptr, void* point)
{
	static_cast<QGraphicsScale*>(ptr)->setOrigin(*static_cast<QVector3D*>(point));
}

void QGraphicsScale_SetXScale(void* ptr, double vqr)
{
	static_cast<QGraphicsScale*>(ptr)->setXScale(vqr);
}

void QGraphicsScale_SetYScale(void* ptr, double vqr)
{
	static_cast<QGraphicsScale*>(ptr)->setYScale(vqr);
}

void QGraphicsScale_SetZScale(void* ptr, double vqr)
{
	static_cast<QGraphicsScale*>(ptr)->setZScale(vqr);
}

double QGraphicsScale_XScale(void* ptr)
{
	return static_cast<QGraphicsScale*>(ptr)->xScale();
}

void QGraphicsScale_ConnectXScaleChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::xScaleChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_XScaleChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsScale_DisconnectXScaleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::xScaleChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_XScaleChanged));
}

void QGraphicsScale_XScaleChanged(void* ptr)
{
	static_cast<QGraphicsScale*>(ptr)->xScaleChanged();
}

double QGraphicsScale_YScale(void* ptr)
{
	return static_cast<QGraphicsScale*>(ptr)->yScale();
}

void QGraphicsScale_ConnectYScaleChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::yScaleChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_YScaleChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsScale_DisconnectYScaleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::yScaleChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_YScaleChanged));
}

void QGraphicsScale_YScaleChanged(void* ptr)
{
	static_cast<QGraphicsScale*>(ptr)->yScaleChanged();
}

double QGraphicsScale_ZScale(void* ptr)
{
	return static_cast<QGraphicsScale*>(ptr)->zScale();
}

void QGraphicsScale_ConnectZScaleChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::zScaleChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_ZScaleChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsScale_DisconnectZScaleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::zScaleChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_ZScaleChanged));
}

void QGraphicsScale_ZScaleChanged(void* ptr)
{
	static_cast<QGraphicsScale*>(ptr)->zScaleChanged();
}

void QGraphicsScale_DestroyQGraphicsScale(void* ptr)
{
	static_cast<QGraphicsScale*>(ptr)->~QGraphicsScale();
}

void QGraphicsScale_DestroyQGraphicsScaleDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsScene: public QGraphicsScene
{
public:
	MyQGraphicsScene(QObject *parent = Q_NULLPTR) : QGraphicsScene(parent) {QGraphicsScene_QGraphicsScene_QRegisterMetaType();};
	MyQGraphicsScene(const QRectF &sceneRect, QObject *parent = Q_NULLPTR) : QGraphicsScene(sceneRect, parent) {QGraphicsScene_QGraphicsScene_QRegisterMetaType();};
	MyQGraphicsScene(qreal x, qreal y, qreal width, qreal height, QObject *parent = Q_NULLPTR) : QGraphicsScene(x, y, width, height, parent) {QGraphicsScene_QGraphicsScene_QRegisterMetaType();};
	void advance() { callbackQGraphicsScene_Advance(this); };
	void Signal_Changed(const QList<QRectF> & region) { callbackQGraphicsScene_Changed(this, ({ QList<QRectF>* tmpValuea94a58 = new QList<QRectF>(region); QtWidgets_PackedList { tmpValuea94a58, tmpValuea94a58->size() }; })); };
	void clear() { callbackQGraphicsScene_Clear(this); };
	void clearSelection() { callbackQGraphicsScene_ClearSelection(this); };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * contextMenuEvent) { callbackQGraphicsScene_ContextMenuEvent(this, contextMenuEvent); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsScene_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsScene_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsScene_DragMoveEvent(this, event); };
	void drawBackground(QPainter * painter, const QRectF & rect) { callbackQGraphicsScene_DrawBackground(this, painter, const_cast<QRectF*>(&rect)); };
	void drawForeground(QPainter * painter, const QRectF & rect) { callbackQGraphicsScene_DrawForeground(this, painter, const_cast<QRectF*>(&rect)); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsScene_DropEvent(this, event); };
	bool event(QEvent * event) { return callbackQGraphicsScene_Event(this, event) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsScene_EventFilter(this, watched, event) != 0; };
	void focusInEvent(QFocusEvent * focusEvent) { callbackQGraphicsScene_FocusInEvent(this, focusEvent); };
	void Signal_FocusItemChanged(QGraphicsItem * newFocusItem, QGraphicsItem * oldFocusItem, Qt::FocusReason reason) { callbackQGraphicsScene_FocusItemChanged(this, newFocusItem, oldFocusItem, reason); };
	bool focusNextPrevChild(bool next) { return callbackQGraphicsScene_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * focusEvent) { callbackQGraphicsScene_FocusOutEvent(this, focusEvent); };
	void helpEvent(QGraphicsSceneHelpEvent * helpEvent) { callbackQGraphicsScene_HelpEvent(this, helpEvent); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsScene_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsScene_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void invalidate(const QRectF & rect, QGraphicsScene::SceneLayers layers) { callbackQGraphicsScene_Invalidate(this, const_cast<QRectF*>(&rect), layers); };
	void keyPressEvent(QKeyEvent * keyEvent) { callbackQGraphicsScene_KeyPressEvent(this, keyEvent); };
	void keyReleaseEvent(QKeyEvent * keyEvent) { callbackQGraphicsScene_KeyReleaseEvent(this, keyEvent); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * mouseEvent) { callbackQGraphicsScene_MouseDoubleClickEvent(this, mouseEvent); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * mouseEvent) { callbackQGraphicsScene_MouseMoveEvent(this, mouseEvent); };
	void mousePressEvent(QGraphicsSceneMouseEvent * mouseEvent) { callbackQGraphicsScene_MousePressEvent(this, mouseEvent); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * mouseEvent) { callbackQGraphicsScene_MouseReleaseEvent(this, mouseEvent); };
	void Signal_SceneRectChanged(const QRectF & rect) { callbackQGraphicsScene_SceneRectChanged(this, const_cast<QRectF*>(&rect)); };
	void Signal_SelectionChanged() { callbackQGraphicsScene_SelectionChanged(this); };
	void update(const QRectF & rect) { callbackQGraphicsScene_Update(this, const_cast<QRectF*>(&rect)); };
	void wheelEvent(QGraphicsSceneWheelEvent * wheelEvent) { callbackQGraphicsScene_WheelEvent(this, wheelEvent); };
	 ~MyQGraphicsScene() { callbackQGraphicsScene_DestroyQGraphicsScene(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsScene_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsScene_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsScene_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsScene_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsScene_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsScene_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsScene_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsScene_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsScene_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsScene*)
Q_DECLARE_METATYPE(MyQGraphicsScene*)

int QGraphicsScene_QGraphicsScene_QRegisterMetaType(){qRegisterMetaType<QGraphicsScene*>(); return qRegisterMetaType<MyQGraphicsScene*>();}

void* QGraphicsScene_NewQGraphicsScene(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(static_cast<QWindow*>(parent));
	} else {
		return new MyQGraphicsScene(static_cast<QObject*>(parent));
	}
}

void* QGraphicsScene_NewQGraphicsScene2(void* sceneRect, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QWindow*>(parent));
	} else {
		return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QObject*>(parent));
	}
}

void* QGraphicsScene_NewQGraphicsScene3(double x, double y, double width, double height, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QWindow*>(parent));
	} else {
		return new MyQGraphicsScene(x, y, width, height, static_cast<QObject*>(parent));
	}
}

void* QGraphicsScene_ActivePanel(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->activePanel();
}

void* QGraphicsScene_ActiveWindow(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->activeWindow();
}

void* QGraphicsScene_AddEllipse(void* ptr, void* rect, void* pen, void* brush)
{
	return static_cast<QGraphicsScene*>(ptr)->addEllipse(*static_cast<QRectF*>(rect), *static_cast<QPen*>(pen), *static_cast<QBrush*>(brush));
}

void* QGraphicsScene_AddEllipse2(void* ptr, double x, double y, double w, double h, void* pen, void* brush)
{
	return static_cast<QGraphicsScene*>(ptr)->addEllipse(x, y, w, h, *static_cast<QPen*>(pen), *static_cast<QBrush*>(brush));
}

void QGraphicsScene_AddItem(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsScene*>(ptr)->addItem(static_cast<QGraphicsObject*>(item));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsScene*>(ptr)->addItem(static_cast<QGraphicsWidget*>(item));
	} else {
		static_cast<QGraphicsScene*>(ptr)->addItem(static_cast<QGraphicsItem*>(item));
	}
}

void* QGraphicsScene_AddLine(void* ptr, void* line, void* pen)
{
	return static_cast<QGraphicsScene*>(ptr)->addLine(*static_cast<QLineF*>(line), *static_cast<QPen*>(pen));
}

void* QGraphicsScene_AddLine2(void* ptr, double x1, double y1, double x2, double y2, void* pen)
{
	return static_cast<QGraphicsScene*>(ptr)->addLine(x1, y1, x2, y2, *static_cast<QPen*>(pen));
}

void* QGraphicsScene_AddPath(void* ptr, void* path, void* pen, void* brush)
{
	return static_cast<QGraphicsScene*>(ptr)->addPath(*static_cast<QPainterPath*>(path), *static_cast<QPen*>(pen), *static_cast<QBrush*>(brush));
}

void* QGraphicsScene_AddPixmap(void* ptr, void* pixmap)
{
	return static_cast<QGraphicsScene*>(ptr)->addPixmap(*static_cast<QPixmap*>(pixmap));
}

void* QGraphicsScene_AddPolygon(void* ptr, void* polygon, void* pen, void* brush)
{
	return static_cast<QGraphicsScene*>(ptr)->addPolygon(*static_cast<QPolygonF*>(polygon), *static_cast<QPen*>(pen), *static_cast<QBrush*>(brush));
}

void* QGraphicsScene_AddRect(void* ptr, void* rect, void* pen, void* brush)
{
	return static_cast<QGraphicsScene*>(ptr)->addRect(*static_cast<QRectF*>(rect), *static_cast<QPen*>(pen), *static_cast<QBrush*>(brush));
}

void* QGraphicsScene_AddRect2(void* ptr, double x, double y, double w, double h, void* pen, void* brush)
{
	return static_cast<QGraphicsScene*>(ptr)->addRect(x, y, w, h, *static_cast<QPen*>(pen), *static_cast<QBrush*>(brush));
}

void* QGraphicsScene_AddSimpleText(void* ptr, struct QtWidgets_PackedString text, void* font)
{
	return static_cast<QGraphicsScene*>(ptr)->addSimpleText(QString::fromUtf8(text.data, text.len), *static_cast<QFont*>(font));
}

void* QGraphicsScene_AddText(void* ptr, struct QtWidgets_PackedString text, void* font)
{
	return static_cast<QGraphicsScene*>(ptr)->addText(QString::fromUtf8(text.data, text.len), *static_cast<QFont*>(font));
}

void* QGraphicsScene_AddWidget(void* ptr, void* widget, long long wFlags)
{
		return static_cast<QGraphicsScene*>(ptr)->addWidget(static_cast<QWidget*>(widget), static_cast<Qt::WindowType>(wFlags));
}

void QGraphicsScene_Advance(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsScene*>(ptr), "advance");
}

void QGraphicsScene_AdvanceDefault(void* ptr)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::advance();
}

void* QGraphicsScene_BackgroundBrush(void* ptr)
{
	return new QBrush(static_cast<QGraphicsScene*>(ptr)->backgroundBrush());
}

int QGraphicsScene_BspTreeDepth(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->bspTreeDepth();
}

void QGraphicsScene_ConnectChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsScene*>(ptr), static_cast<void (QGraphicsScene::*)(const QList<QRectF> &)>(&QGraphicsScene::changed), static_cast<MyQGraphicsScene*>(ptr), static_cast<void (MyQGraphicsScene::*)(const QList<QRectF> &)>(&MyQGraphicsScene::Signal_Changed), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsScene_DisconnectChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsScene*>(ptr), static_cast<void (QGraphicsScene::*)(const QList<QRectF> &)>(&QGraphicsScene::changed), static_cast<MyQGraphicsScene*>(ptr), static_cast<void (MyQGraphicsScene::*)(const QList<QRectF> &)>(&MyQGraphicsScene::Signal_Changed));
}

void QGraphicsScene_Changed(void* ptr, void* region)
{
	static_cast<QGraphicsScene*>(ptr)->changed(*static_cast<QList<QRectF>*>(region));
}

void QGraphicsScene_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsScene*>(ptr), "clear");
}

void QGraphicsScene_ClearDefault(void* ptr)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::clear();
}

void QGraphicsScene_ClearFocus(void* ptr)
{
	static_cast<QGraphicsScene*>(ptr)->clearFocus();
}

void QGraphicsScene_ClearSelection(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsScene*>(ptr), "clearSelection");
}

void QGraphicsScene_ClearSelectionDefault(void* ptr)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::clearSelection();
}

struct QtWidgets_PackedList QGraphicsScene_CollidingItems(void* ptr, void* item, long long mode)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
		return ({ QList<QGraphicsItem *>* tmpValue394039 = new QList<QGraphicsItem *>(static_cast<QGraphicsScene*>(ptr)->collidingItems(static_cast<QGraphicsObject*>(item), static_cast<Qt::ItemSelectionMode>(mode))); QtWidgets_PackedList { tmpValue394039, tmpValue394039->size() }; });
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		return ({ QList<QGraphicsItem *>* tmpValue394039 = new QList<QGraphicsItem *>(static_cast<QGraphicsScene*>(ptr)->collidingItems(static_cast<QGraphicsWidget*>(item), static_cast<Qt::ItemSelectionMode>(mode))); QtWidgets_PackedList { tmpValue394039, tmpValue394039->size() }; });
	} else {
		return ({ QList<QGraphicsItem *>* tmpValue394039 = new QList<QGraphicsItem *>(static_cast<QGraphicsScene*>(ptr)->collidingItems(static_cast<QGraphicsItem*>(item), static_cast<Qt::ItemSelectionMode>(mode))); QtWidgets_PackedList { tmpValue394039, tmpValue394039->size() }; });
	}
}

void QGraphicsScene_ContextMenuEvent(void* ptr, void* contextMenuEvent)
{
	static_cast<QGraphicsScene*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(contextMenuEvent));
}

void QGraphicsScene_ContextMenuEventDefault(void* ptr, void* contextMenuEvent)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(contextMenuEvent));
}

void* QGraphicsScene_CreateItemGroup(void* ptr, void* items)
{
	return static_cast<QGraphicsScene*>(ptr)->createItemGroup(*static_cast<QList<QGraphicsItem *>*>(items));
}

void QGraphicsScene_DestroyItemGroup(void* ptr, void* group)
{
	static_cast<QGraphicsScene*>(ptr)->destroyItemGroup(static_cast<QGraphicsItemGroup*>(group));
}

void QGraphicsScene_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsScene*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsScene_DragEnterEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsScene_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsScene*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsScene_DragLeaveEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsScene_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsScene*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsScene_DragMoveEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsScene_DrawBackground(void* ptr, void* painter, void* rect)
{
	static_cast<QGraphicsScene*>(ptr)->drawBackground(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect));
}

void QGraphicsScene_DrawBackgroundDefault(void* ptr, void* painter, void* rect)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::drawBackground(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect));
}

void QGraphicsScene_DrawForeground(void* ptr, void* painter, void* rect)
{
	static_cast<QGraphicsScene*>(ptr)->drawForeground(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect));
}

void QGraphicsScene_DrawForegroundDefault(void* ptr, void* painter, void* rect)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::drawForeground(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect));
}

void QGraphicsScene_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsScene*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsScene_DropEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

char QGraphicsScene_EventDefault(void* ptr, void* event)
{
		return static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::event(static_cast<QEvent*>(event));
}

char QGraphicsScene_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QGraphicsScene_FocusInEvent(void* ptr, void* focusEvent)
{
	static_cast<QGraphicsScene*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(focusEvent));
}

void QGraphicsScene_FocusInEventDefault(void* ptr, void* focusEvent)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::focusInEvent(static_cast<QFocusEvent*>(focusEvent));
}

void* QGraphicsScene_FocusItem(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->focusItem();
}

void QGraphicsScene_ConnectFocusItemChanged(void* ptr, long long t)
{
	qRegisterMetaType<Qt::FocusReason>();
	QObject::connect(static_cast<QGraphicsScene*>(ptr), static_cast<void (QGraphicsScene::*)(QGraphicsItem *, QGraphicsItem *, Qt::FocusReason)>(&QGraphicsScene::focusItemChanged), static_cast<MyQGraphicsScene*>(ptr), static_cast<void (MyQGraphicsScene::*)(QGraphicsItem *, QGraphicsItem *, Qt::FocusReason)>(&MyQGraphicsScene::Signal_FocusItemChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsScene_DisconnectFocusItemChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsScene*>(ptr), static_cast<void (QGraphicsScene::*)(QGraphicsItem *, QGraphicsItem *, Qt::FocusReason)>(&QGraphicsScene::focusItemChanged), static_cast<MyQGraphicsScene*>(ptr), static_cast<void (MyQGraphicsScene::*)(QGraphicsItem *, QGraphicsItem *, Qt::FocusReason)>(&MyQGraphicsScene::Signal_FocusItemChanged));
}

void QGraphicsScene_FocusItemChanged(void* ptr, void* newFocusItem, void* oldFocusItem, long long reason)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(newFocusItem))) {
		static_cast<QGraphicsScene*>(ptr)->focusItemChanged(static_cast<QGraphicsObject*>(newFocusItem), static_cast<QGraphicsItem*>(oldFocusItem), static_cast<Qt::FocusReason>(reason));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(newFocusItem))) {
		static_cast<QGraphicsScene*>(ptr)->focusItemChanged(static_cast<QGraphicsWidget*>(newFocusItem), static_cast<QGraphicsItem*>(oldFocusItem), static_cast<Qt::FocusReason>(reason));
	} else {
		static_cast<QGraphicsScene*>(ptr)->focusItemChanged(static_cast<QGraphicsItem*>(newFocusItem), static_cast<QGraphicsItem*>(oldFocusItem), static_cast<Qt::FocusReason>(reason));
	}
}

char QGraphicsScene_FocusNextPrevChild(void* ptr, char next)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QGraphicsScene*>(ptr), "focusNextPrevChild", Q_RETURN_ARG(bool, returnArg), Q_ARG(bool, next != 0));
	return returnArg;
}

char QGraphicsScene_FocusNextPrevChildDefault(void* ptr, char next)
{
		return static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::focusNextPrevChild(next != 0);
}

char QGraphicsScene_FocusOnTouch(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->focusOnTouch();
}

void QGraphicsScene_FocusOutEvent(void* ptr, void* focusEvent)
{
	static_cast<QGraphicsScene*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(focusEvent));
}

void QGraphicsScene_FocusOutEventDefault(void* ptr, void* focusEvent)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::focusOutEvent(static_cast<QFocusEvent*>(focusEvent));
}

void* QGraphicsScene_Font(void* ptr)
{
	return new QFont(static_cast<QGraphicsScene*>(ptr)->font());
}

void* QGraphicsScene_ForegroundBrush(void* ptr)
{
	return new QBrush(static_cast<QGraphicsScene*>(ptr)->foregroundBrush());
}

char QGraphicsScene_HasFocus(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->hasFocus();
}

double QGraphicsScene_Height(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->height();
}

void QGraphicsScene_HelpEvent(void* ptr, void* helpEvent)
{
	static_cast<QGraphicsScene*>(ptr)->helpEvent(static_cast<QGraphicsSceneHelpEvent*>(helpEvent));
}

void QGraphicsScene_HelpEventDefault(void* ptr, void* helpEvent)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::helpEvent(static_cast<QGraphicsSceneHelpEvent*>(helpEvent));
}

void QGraphicsScene_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsScene*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsScene_InputMethodEventDefault(void* ptr, void* event)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsScene_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsScene*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsScene_InputMethodQueryDefault(void* ptr, long long query)
{
		return new QVariant(static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QGraphicsScene_Invalidate(void* ptr, void* rect, long long layers)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsScene*>(ptr), "invalidate", Q_ARG(const QRectF, *static_cast<QRectF*>(rect)), Q_ARG(QGraphicsScene::SceneLayers, static_cast<QGraphicsScene::SceneLayer>(layers)));
}

void QGraphicsScene_InvalidateDefault(void* ptr, void* rect, long long layers)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::invalidate(*static_cast<QRectF*>(rect), static_cast<QGraphicsScene::SceneLayer>(layers));
}

void QGraphicsScene_Invalidate2(void* ptr, double x, double y, double w, double h, long long layers)
{
	static_cast<QGraphicsScene*>(ptr)->invalidate(x, y, w, h, static_cast<QGraphicsScene::SceneLayer>(layers));
}

char QGraphicsScene_IsActive(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->isActive();
}

char QGraphicsScene_IsSortCacheEnabled(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->isSortCacheEnabled();
}

void* QGraphicsScene_ItemAt(void* ptr, void* position, void* deviceTransform)
{
	return static_cast<QGraphicsScene*>(ptr)->itemAt(*static_cast<QPointF*>(position), *static_cast<QTransform*>(deviceTransform));
}

void* QGraphicsScene_ItemAt4(void* ptr, double x, double y, void* deviceTransform)
{
	return static_cast<QGraphicsScene*>(ptr)->itemAt(x, y, *static_cast<QTransform*>(deviceTransform));
}

long long QGraphicsScene_ItemIndexMethod(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->itemIndexMethod();
}

struct QtWidgets_PackedList QGraphicsScene_Items(void* ptr, long long order)
{
	return ({ QList<QGraphicsItem *>* tmpValuea79113 = new QList<QGraphicsItem *>(static_cast<QGraphicsScene*>(ptr)->items(static_cast<Qt::SortOrder>(order))); QtWidgets_PackedList { tmpValuea79113, tmpValuea79113->size() }; });
}

struct QtWidgets_PackedList QGraphicsScene_Items2(void* ptr, void* pos, long long mode, long long order, void* deviceTransform)
{
	return ({ QList<QGraphicsItem *>* tmpValue68679d = new QList<QGraphicsItem *>(static_cast<QGraphicsScene*>(ptr)->items(*static_cast<QPointF*>(pos), static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order), *static_cast<QTransform*>(deviceTransform))); QtWidgets_PackedList { tmpValue68679d, tmpValue68679d->size() }; });
}

struct QtWidgets_PackedList QGraphicsScene_Items3(void* ptr, void* rect, long long mode, long long order, void* deviceTransform)
{
	return ({ QList<QGraphicsItem *>* tmpValuec23b67 = new QList<QGraphicsItem *>(static_cast<QGraphicsScene*>(ptr)->items(*static_cast<QRectF*>(rect), static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order), *static_cast<QTransform*>(deviceTransform))); QtWidgets_PackedList { tmpValuec23b67, tmpValuec23b67->size() }; });
}

struct QtWidgets_PackedList QGraphicsScene_Items4(void* ptr, void* polygon, long long mode, long long order, void* deviceTransform)
{
	return ({ QList<QGraphicsItem *>* tmpValue73aac6 = new QList<QGraphicsItem *>(static_cast<QGraphicsScene*>(ptr)->items(*static_cast<QPolygonF*>(polygon), static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order), *static_cast<QTransform*>(deviceTransform))); QtWidgets_PackedList { tmpValue73aac6, tmpValue73aac6->size() }; });
}

struct QtWidgets_PackedList QGraphicsScene_Items5(void* ptr, void* path, long long mode, long long order, void* deviceTransform)
{
	return ({ QList<QGraphicsItem *>* tmpValue0a280c = new QList<QGraphicsItem *>(static_cast<QGraphicsScene*>(ptr)->items(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order), *static_cast<QTransform*>(deviceTransform))); QtWidgets_PackedList { tmpValue0a280c, tmpValue0a280c->size() }; });
}

struct QtWidgets_PackedList QGraphicsScene_Items7(void* ptr, double x, double y, double w, double h, long long mode, long long order, void* deviceTransform)
{
	return ({ QList<QGraphicsItem *>* tmpValuee3277d = new QList<QGraphicsItem *>(static_cast<QGraphicsScene*>(ptr)->items(x, y, w, h, static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order), *static_cast<QTransform*>(deviceTransform))); QtWidgets_PackedList { tmpValuee3277d, tmpValuee3277d->size() }; });
}

void* QGraphicsScene_ItemsBoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsScene*>(ptr)->itemsBoundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsScene_KeyPressEvent(void* ptr, void* keyEvent)
{
	static_cast<QGraphicsScene*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(keyEvent));
}

void QGraphicsScene_KeyPressEventDefault(void* ptr, void* keyEvent)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::keyPressEvent(static_cast<QKeyEvent*>(keyEvent));
}

void QGraphicsScene_KeyReleaseEvent(void* ptr, void* keyEvent)
{
	static_cast<QGraphicsScene*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(keyEvent));
}

void QGraphicsScene_KeyReleaseEventDefault(void* ptr, void* keyEvent)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::keyReleaseEvent(static_cast<QKeyEvent*>(keyEvent));
}

double QGraphicsScene_MinimumRenderSize(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->minimumRenderSize();
}

void QGraphicsScene_MouseDoubleClickEvent(void* ptr, void* mouseEvent)
{
	static_cast<QGraphicsScene*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(mouseEvent));
}

void QGraphicsScene_MouseDoubleClickEventDefault(void* ptr, void* mouseEvent)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(mouseEvent));
}

void* QGraphicsScene_MouseGrabberItem(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->mouseGrabberItem();
}

void QGraphicsScene_MouseMoveEvent(void* ptr, void* mouseEvent)
{
	static_cast<QGraphicsScene*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(mouseEvent));
}

void QGraphicsScene_MouseMoveEventDefault(void* ptr, void* mouseEvent)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(mouseEvent));
}

void QGraphicsScene_MousePressEvent(void* ptr, void* mouseEvent)
{
	static_cast<QGraphicsScene*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(mouseEvent));
}

void QGraphicsScene_MousePressEventDefault(void* ptr, void* mouseEvent)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(mouseEvent));
}

void QGraphicsScene_MouseReleaseEvent(void* ptr, void* mouseEvent)
{
	static_cast<QGraphicsScene*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(mouseEvent));
}

void QGraphicsScene_MouseReleaseEventDefault(void* ptr, void* mouseEvent)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(mouseEvent));
}

void* QGraphicsScene_Palette(void* ptr)
{
	return new QPalette(static_cast<QGraphicsScene*>(ptr)->palette());
}

void QGraphicsScene_RemoveItem(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsScene*>(ptr)->removeItem(static_cast<QGraphicsObject*>(item));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsScene*>(ptr)->removeItem(static_cast<QGraphicsWidget*>(item));
	} else {
		static_cast<QGraphicsScene*>(ptr)->removeItem(static_cast<QGraphicsItem*>(item));
	}
}

void QGraphicsScene_Render(void* ptr, void* painter, void* target, void* source, long long aspectRatioMode)
{
	static_cast<QGraphicsScene*>(ptr)->render(static_cast<QPainter*>(painter), *static_cast<QRectF*>(target), *static_cast<QRectF*>(source), static_cast<Qt::AspectRatioMode>(aspectRatioMode));
}

void* QGraphicsScene_SceneRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsScene*>(ptr)->sceneRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsScene_ConnectSceneRectChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsScene*>(ptr), static_cast<void (QGraphicsScene::*)(const QRectF &)>(&QGraphicsScene::sceneRectChanged), static_cast<MyQGraphicsScene*>(ptr), static_cast<void (MyQGraphicsScene::*)(const QRectF &)>(&MyQGraphicsScene::Signal_SceneRectChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsScene_DisconnectSceneRectChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsScene*>(ptr), static_cast<void (QGraphicsScene::*)(const QRectF &)>(&QGraphicsScene::sceneRectChanged), static_cast<MyQGraphicsScene*>(ptr), static_cast<void (MyQGraphicsScene::*)(const QRectF &)>(&MyQGraphicsScene::Signal_SceneRectChanged));
}

void QGraphicsScene_SceneRectChanged(void* ptr, void* rect)
{
	static_cast<QGraphicsScene*>(ptr)->sceneRectChanged(*static_cast<QRectF*>(rect));
}

struct QtWidgets_PackedList QGraphicsScene_SelectedItems(void* ptr)
{
	return ({ QList<QGraphicsItem *>* tmpValue591fec = new QList<QGraphicsItem *>(static_cast<QGraphicsScene*>(ptr)->selectedItems()); QtWidgets_PackedList { tmpValue591fec, tmpValue591fec->size() }; });
}

void* QGraphicsScene_SelectionArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsScene*>(ptr)->selectionArea());
}

void QGraphicsScene_ConnectSelectionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsScene*>(ptr), static_cast<void (QGraphicsScene::*)()>(&QGraphicsScene::selectionChanged), static_cast<MyQGraphicsScene*>(ptr), static_cast<void (MyQGraphicsScene::*)()>(&MyQGraphicsScene::Signal_SelectionChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsScene_DisconnectSelectionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsScene*>(ptr), static_cast<void (QGraphicsScene::*)()>(&QGraphicsScene::selectionChanged), static_cast<MyQGraphicsScene*>(ptr), static_cast<void (MyQGraphicsScene::*)()>(&MyQGraphicsScene::Signal_SelectionChanged));
}

void QGraphicsScene_SelectionChanged(void* ptr)
{
	static_cast<QGraphicsScene*>(ptr)->selectionChanged();
}

char QGraphicsScene_SendEvent(void* ptr, void* item, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
		return static_cast<QGraphicsScene*>(ptr)->sendEvent(static_cast<QGraphicsObject*>(item), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		return static_cast<QGraphicsScene*>(ptr)->sendEvent(static_cast<QGraphicsWidget*>(item), static_cast<QEvent*>(event));
	} else {
		return static_cast<QGraphicsScene*>(ptr)->sendEvent(static_cast<QGraphicsItem*>(item), static_cast<QEvent*>(event));
	}
}

void QGraphicsScene_SetActivePanel(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsScene*>(ptr)->setActivePanel(static_cast<QGraphicsObject*>(item));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsScene*>(ptr)->setActivePanel(static_cast<QGraphicsWidget*>(item));
	} else {
		static_cast<QGraphicsScene*>(ptr)->setActivePanel(static_cast<QGraphicsItem*>(item));
	}
}

void QGraphicsScene_SetActiveWindow(void* ptr, void* widget)
{
		static_cast<QGraphicsScene*>(ptr)->setActiveWindow(static_cast<QGraphicsWidget*>(widget));
}

void QGraphicsScene_SetBackgroundBrush(void* ptr, void* brush)
{
	static_cast<QGraphicsScene*>(ptr)->setBackgroundBrush(*static_cast<QBrush*>(brush));
}

void QGraphicsScene_SetBspTreeDepth(void* ptr, int depth)
{
	static_cast<QGraphicsScene*>(ptr)->setBspTreeDepth(depth);
}

void QGraphicsScene_SetFocus(void* ptr, long long focusReason)
{
	static_cast<QGraphicsScene*>(ptr)->setFocus(static_cast<Qt::FocusReason>(focusReason));
}

void QGraphicsScene_SetFocusItem(void* ptr, void* item, long long focusReason)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsScene*>(ptr)->setFocusItem(static_cast<QGraphicsObject*>(item), static_cast<Qt::FocusReason>(focusReason));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsScene*>(ptr)->setFocusItem(static_cast<QGraphicsWidget*>(item), static_cast<Qt::FocusReason>(focusReason));
	} else {
		static_cast<QGraphicsScene*>(ptr)->setFocusItem(static_cast<QGraphicsItem*>(item), static_cast<Qt::FocusReason>(focusReason));
	}
}

void QGraphicsScene_SetFocusOnTouch(void* ptr, char enabled)
{
	static_cast<QGraphicsScene*>(ptr)->setFocusOnTouch(enabled != 0);
}

void QGraphicsScene_SetFont(void* ptr, void* font)
{
	static_cast<QGraphicsScene*>(ptr)->setFont(*static_cast<QFont*>(font));
}

void QGraphicsScene_SetForegroundBrush(void* ptr, void* brush)
{
	static_cast<QGraphicsScene*>(ptr)->setForegroundBrush(*static_cast<QBrush*>(brush));
}

void QGraphicsScene_SetItemIndexMethod(void* ptr, long long method)
{
	static_cast<QGraphicsScene*>(ptr)->setItemIndexMethod(static_cast<QGraphicsScene::ItemIndexMethod>(method));
}

void QGraphicsScene_SetMinimumRenderSize(void* ptr, double minSize)
{
	static_cast<QGraphicsScene*>(ptr)->setMinimumRenderSize(minSize);
}

void QGraphicsScene_SetPalette(void* ptr, void* palette)
{
	static_cast<QGraphicsScene*>(ptr)->setPalette(*static_cast<QPalette*>(palette));
}

void QGraphicsScene_SetSceneRect(void* ptr, void* rect)
{
	static_cast<QGraphicsScene*>(ptr)->setSceneRect(*static_cast<QRectF*>(rect));
}

void QGraphicsScene_SetSceneRect2(void* ptr, double x, double y, double w, double h)
{
	static_cast<QGraphicsScene*>(ptr)->setSceneRect(x, y, w, h);
}

void QGraphicsScene_SetSelectionArea(void* ptr, void* path, void* deviceTransform)
{
	static_cast<QGraphicsScene*>(ptr)->setSelectionArea(*static_cast<QPainterPath*>(path), *static_cast<QTransform*>(deviceTransform));
}

void QGraphicsScene_SetSelectionArea2(void* ptr, void* path, long long mode, void* deviceTransform)
{
	static_cast<QGraphicsScene*>(ptr)->setSelectionArea(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode), *static_cast<QTransform*>(deviceTransform));
}

void QGraphicsScene_SetSelectionArea3(void* ptr, void* path, long long selectionOperation, long long mode, void* deviceTransform)
{
	static_cast<QGraphicsScene*>(ptr)->setSelectionArea(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionOperation>(selectionOperation), static_cast<Qt::ItemSelectionMode>(mode), *static_cast<QTransform*>(deviceTransform));
}

void QGraphicsScene_SetSortCacheEnabled(void* ptr, char enabled)
{
	static_cast<QGraphicsScene*>(ptr)->setSortCacheEnabled(enabled != 0);
}

void QGraphicsScene_SetStickyFocus(void* ptr, char enabled)
{
	static_cast<QGraphicsScene*>(ptr)->setStickyFocus(enabled != 0);
}

void QGraphicsScene_SetStyle(void* ptr, void* style)
{
	static_cast<QGraphicsScene*>(ptr)->setStyle(static_cast<QStyle*>(style));
}

char QGraphicsScene_StickyFocus(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->stickyFocus();
}

void* QGraphicsScene_Style(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->style();
}

void QGraphicsScene_Update(void* ptr, void* rect)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsScene*>(ptr), "update", Q_ARG(const QRectF, *static_cast<QRectF*>(rect)));
}

void QGraphicsScene_UpdateDefault(void* ptr, void* rect)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::update(*static_cast<QRectF*>(rect));
}

void QGraphicsScene_Update2(void* ptr, double x, double y, double w, double h)
{
	static_cast<QGraphicsScene*>(ptr)->update(x, y, w, h);
}

struct QtWidgets_PackedList QGraphicsScene_Views(void* ptr)
{
	return ({ QList<QGraphicsView *>* tmpValuec79e3c = new QList<QGraphicsView *>(static_cast<QGraphicsScene*>(ptr)->views()); QtWidgets_PackedList { tmpValuec79e3c, tmpValuec79e3c->size() }; });
}

void QGraphicsScene_WheelEvent(void* ptr, void* wheelEvent)
{
	static_cast<QGraphicsScene*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(wheelEvent));
}

void QGraphicsScene_WheelEventDefault(void* ptr, void* wheelEvent)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(wheelEvent));
}

double QGraphicsScene_Width(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->width();
}

void QGraphicsScene_DestroyQGraphicsScene(void* ptr)
{
	static_cast<QGraphicsScene*>(ptr)->~QGraphicsScene();
}

void QGraphicsScene_DestroyQGraphicsSceneDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QGraphicsScene___changed_region_atList(void* ptr, int i)
{
	return ({ QRectF tmpValue = ({QRectF tmp = static_cast<QList<QRectF>*>(ptr)->at(i); if (i == static_cast<QList<QRectF>*>(ptr)->size()-1) { static_cast<QList<QRectF>*>(ptr)->~QList(); free(ptr); }; tmp; }); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

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

void* QGraphicsScene___changed_region_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QRectF>();
}

void* QGraphicsScene___collidingItems_atList(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsScene___collidingItems_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsScene___collidingItems_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsScene___createItemGroup_items_atList(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsScene___createItemGroup_items_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsScene___createItemGroup_items_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsScene___items_atList(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsScene___items_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsScene___items_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsScene___items_atList2(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsScene___items_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsScene___items_newList2(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsScene___items_atList3(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsScene___items_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsScene___items_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsScene___items_atList4(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsScene___items_setList4(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsScene___items_newList4(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsScene___items_atList5(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsScene___items_setList5(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsScene___items_newList5(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsScene___items_atList7(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsScene___items_setList7(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsScene___items_newList7(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsScene___selectedItems_atList(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsScene___selectedItems_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsScene___selectedItems_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsScene___views_atList(void* ptr, int i)
{
	return ({QGraphicsView * tmp = static_cast<QList<QGraphicsView *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsView *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsView *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QGraphicsScene___views_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsView *>();
}

void* QGraphicsScene___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsScene___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QGraphicsScene___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QGraphicsScene___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsScene___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QGraphicsScene___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsScene___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

void QGraphicsScene_DeleteLaterDefault(void* ptr)
{
		static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::deleteLater();
}

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

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

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

class MyQGraphicsSceneContextMenuEvent: public QGraphicsSceneContextMenuEvent
{
public:
	 ~MyQGraphicsSceneContextMenuEvent() { callbackQGraphicsSceneContextMenuEvent_DestroyQGraphicsSceneContextMenuEvent(this); };
};

Q_DECLARE_METATYPE(QGraphicsSceneContextMenuEvent*)
Q_DECLARE_METATYPE(MyQGraphicsSceneContextMenuEvent*)

int QGraphicsSceneContextMenuEvent_QGraphicsSceneContextMenuEvent_QRegisterMetaType(){qRegisterMetaType<QGraphicsSceneContextMenuEvent*>(); return qRegisterMetaType<MyQGraphicsSceneContextMenuEvent*>();}

long long QGraphicsSceneContextMenuEvent_Modifiers(void* ptr)
{
	return static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->modifiers();
}

void* QGraphicsSceneContextMenuEvent_Pos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->pos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

long long QGraphicsSceneContextMenuEvent_Reason(void* ptr)
{
	return static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->reason();
}

void* QGraphicsSceneContextMenuEvent_ScenePos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->scenePos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneContextMenuEvent_ScreenPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->screenPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QGraphicsSceneContextMenuEvent_DestroyQGraphicsSceneContextMenuEvent(void* ptr)
{
	static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->~QGraphicsSceneContextMenuEvent();
}

void QGraphicsSceneContextMenuEvent_DestroyQGraphicsSceneContextMenuEventDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsSceneDragDropEvent: public QGraphicsSceneDragDropEvent
{
public:
	 ~MyQGraphicsSceneDragDropEvent() { callbackQGraphicsSceneDragDropEvent_DestroyQGraphicsSceneDragDropEvent(this); };
};

Q_DECLARE_METATYPE(QGraphicsSceneDragDropEvent*)
Q_DECLARE_METATYPE(MyQGraphicsSceneDragDropEvent*)

int QGraphicsSceneDragDropEvent_QGraphicsSceneDragDropEvent_QRegisterMetaType(){qRegisterMetaType<QGraphicsSceneDragDropEvent*>(); return qRegisterMetaType<MyQGraphicsSceneDragDropEvent*>();}

void QGraphicsSceneDragDropEvent_AcceptProposedAction(void* ptr)
{
	static_cast<QGraphicsSceneDragDropEvent*>(ptr)->acceptProposedAction();
}

long long QGraphicsSceneDragDropEvent_Buttons(void* ptr)
{
	return static_cast<QGraphicsSceneDragDropEvent*>(ptr)->buttons();
}

long long QGraphicsSceneDragDropEvent_DropAction(void* ptr)
{
	return static_cast<QGraphicsSceneDragDropEvent*>(ptr)->dropAction();
}

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

long long QGraphicsSceneDragDropEvent_Modifiers(void* ptr)
{
	return static_cast<QGraphicsSceneDragDropEvent*>(ptr)->modifiers();
}

void* QGraphicsSceneDragDropEvent_Pos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneDragDropEvent*>(ptr)->pos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

long long QGraphicsSceneDragDropEvent_PossibleActions(void* ptr)
{
	return static_cast<QGraphicsSceneDragDropEvent*>(ptr)->possibleActions();
}

long long QGraphicsSceneDragDropEvent_ProposedAction(void* ptr)
{
	return static_cast<QGraphicsSceneDragDropEvent*>(ptr)->proposedAction();
}

void* QGraphicsSceneDragDropEvent_ScenePos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneDragDropEvent*>(ptr)->scenePos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneDragDropEvent_ScreenPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QGraphicsSceneDragDropEvent*>(ptr)->screenPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

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

void* QGraphicsSceneDragDropEvent_Source(void* ptr)
{
	return static_cast<QGraphicsSceneDragDropEvent*>(ptr)->source();
}

void QGraphicsSceneDragDropEvent_DestroyQGraphicsSceneDragDropEvent(void* ptr)
{
	static_cast<QGraphicsSceneDragDropEvent*>(ptr)->~QGraphicsSceneDragDropEvent();
}

void QGraphicsSceneDragDropEvent_DestroyQGraphicsSceneDragDropEventDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsSceneEvent: public QGraphicsSceneEvent
{
public:
	 ~MyQGraphicsSceneEvent() { callbackQGraphicsSceneEvent_DestroyQGraphicsSceneEvent(this); };
};

Q_DECLARE_METATYPE(QGraphicsSceneEvent*)
Q_DECLARE_METATYPE(MyQGraphicsSceneEvent*)

int QGraphicsSceneEvent_QGraphicsSceneEvent_QRegisterMetaType(){qRegisterMetaType<QGraphicsSceneEvent*>(); return qRegisterMetaType<MyQGraphicsSceneEvent*>();}

void* QGraphicsSceneEvent_Widget(void* ptr)
{
	return static_cast<QGraphicsSceneEvent*>(ptr)->widget();
}

void QGraphicsSceneEvent_DestroyQGraphicsSceneEvent(void* ptr)
{
	static_cast<QGraphicsSceneEvent*>(ptr)->~QGraphicsSceneEvent();
}

void QGraphicsSceneEvent_DestroyQGraphicsSceneEventDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsSceneHelpEvent: public QGraphicsSceneHelpEvent
{
public:
	 ~MyQGraphicsSceneHelpEvent() { callbackQGraphicsSceneHelpEvent_DestroyQGraphicsSceneHelpEvent(this); };
};

Q_DECLARE_METATYPE(QGraphicsSceneHelpEvent*)
Q_DECLARE_METATYPE(MyQGraphicsSceneHelpEvent*)

int QGraphicsSceneHelpEvent_QGraphicsSceneHelpEvent_QRegisterMetaType(){qRegisterMetaType<QGraphicsSceneHelpEvent*>(); return qRegisterMetaType<MyQGraphicsSceneHelpEvent*>();}

void* QGraphicsSceneHelpEvent_ScenePos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneHelpEvent*>(ptr)->scenePos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneHelpEvent_ScreenPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QGraphicsSceneHelpEvent*>(ptr)->screenPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QGraphicsSceneHelpEvent_DestroyQGraphicsSceneHelpEvent(void* ptr)
{
	static_cast<QGraphicsSceneHelpEvent*>(ptr)->~QGraphicsSceneHelpEvent();
}

void QGraphicsSceneHelpEvent_DestroyQGraphicsSceneHelpEventDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsSceneHoverEvent: public QGraphicsSceneHoverEvent
{
public:
	 ~MyQGraphicsSceneHoverEvent() { callbackQGraphicsSceneHoverEvent_DestroyQGraphicsSceneHoverEvent(this); };
};

Q_DECLARE_METATYPE(QGraphicsSceneHoverEvent*)
Q_DECLARE_METATYPE(MyQGraphicsSceneHoverEvent*)

int QGraphicsSceneHoverEvent_QGraphicsSceneHoverEvent_QRegisterMetaType(){qRegisterMetaType<QGraphicsSceneHoverEvent*>(); return qRegisterMetaType<MyQGraphicsSceneHoverEvent*>();}

void* QGraphicsSceneHoverEvent_LastPos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneHoverEvent*>(ptr)->lastPos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneHoverEvent_LastScenePos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneHoverEvent*>(ptr)->lastScenePos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneHoverEvent_LastScreenPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QGraphicsSceneHoverEvent*>(ptr)->lastScreenPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

long long QGraphicsSceneHoverEvent_Modifiers(void* ptr)
{
	return static_cast<QGraphicsSceneHoverEvent*>(ptr)->modifiers();
}

void* QGraphicsSceneHoverEvent_Pos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneHoverEvent*>(ptr)->pos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneHoverEvent_ScenePos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneHoverEvent*>(ptr)->scenePos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneHoverEvent_ScreenPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QGraphicsSceneHoverEvent*>(ptr)->screenPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QGraphicsSceneHoverEvent_DestroyQGraphicsSceneHoverEvent(void* ptr)
{
	static_cast<QGraphicsSceneHoverEvent*>(ptr)->~QGraphicsSceneHoverEvent();
}

void QGraphicsSceneHoverEvent_DestroyQGraphicsSceneHoverEventDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsSceneMouseEvent: public QGraphicsSceneMouseEvent
{
public:
	 ~MyQGraphicsSceneMouseEvent() { callbackQGraphicsSceneMouseEvent_DestroyQGraphicsSceneMouseEvent(this); };
};

Q_DECLARE_METATYPE(QGraphicsSceneMouseEvent*)
Q_DECLARE_METATYPE(MyQGraphicsSceneMouseEvent*)

int QGraphicsSceneMouseEvent_QGraphicsSceneMouseEvent_QRegisterMetaType(){qRegisterMetaType<QGraphicsSceneMouseEvent*>(); return qRegisterMetaType<MyQGraphicsSceneMouseEvent*>();}

long long QGraphicsSceneMouseEvent_Button(void* ptr)
{
	return static_cast<QGraphicsSceneMouseEvent*>(ptr)->button();
}

void* QGraphicsSceneMouseEvent_ButtonDownPos(void* ptr, long long button)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneMouseEvent*>(ptr)->buttonDownPos(static_cast<Qt::MouseButton>(button)); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneMouseEvent_ButtonDownScenePos(void* ptr, long long button)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneMouseEvent*>(ptr)->buttonDownScenePos(static_cast<Qt::MouseButton>(button)); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneMouseEvent_ButtonDownScreenPos(void* ptr, long long button)
{
	return ({ QPoint tmpValue = static_cast<QGraphicsSceneMouseEvent*>(ptr)->buttonDownScreenPos(static_cast<Qt::MouseButton>(button)); new QPoint(tmpValue.x(), tmpValue.y()); });
}

long long QGraphicsSceneMouseEvent_Buttons(void* ptr)
{
	return static_cast<QGraphicsSceneMouseEvent*>(ptr)->buttons();
}

long long QGraphicsSceneMouseEvent_Flags(void* ptr)
{
	return static_cast<QGraphicsSceneMouseEvent*>(ptr)->flags();
}

void* QGraphicsSceneMouseEvent_LastPos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneMouseEvent*>(ptr)->lastPos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneMouseEvent_LastScenePos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneMouseEvent*>(ptr)->lastScenePos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneMouseEvent_LastScreenPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QGraphicsSceneMouseEvent*>(ptr)->lastScreenPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

long long QGraphicsSceneMouseEvent_Modifiers(void* ptr)
{
	return static_cast<QGraphicsSceneMouseEvent*>(ptr)->modifiers();
}

void* QGraphicsSceneMouseEvent_Pos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneMouseEvent*>(ptr)->pos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneMouseEvent_ScenePos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneMouseEvent*>(ptr)->scenePos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneMouseEvent_ScreenPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QGraphicsSceneMouseEvent*>(ptr)->screenPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

long long QGraphicsSceneMouseEvent_Source(void* ptr)
{
	return static_cast<QGraphicsSceneMouseEvent*>(ptr)->source();
}

void QGraphicsSceneMouseEvent_DestroyQGraphicsSceneMouseEvent(void* ptr)
{
	static_cast<QGraphicsSceneMouseEvent*>(ptr)->~QGraphicsSceneMouseEvent();
}

void QGraphicsSceneMouseEvent_DestroyQGraphicsSceneMouseEventDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsSceneMoveEvent: public QGraphicsSceneMoveEvent
{
public:
	MyQGraphicsSceneMoveEvent() : QGraphicsSceneMoveEvent() {QGraphicsSceneMoveEvent_QGraphicsSceneMoveEvent_QRegisterMetaType();};
	 ~MyQGraphicsSceneMoveEvent() { callbackQGraphicsSceneMoveEvent_DestroyQGraphicsSceneMoveEvent(this); };
};

Q_DECLARE_METATYPE(QGraphicsSceneMoveEvent*)
Q_DECLARE_METATYPE(MyQGraphicsSceneMoveEvent*)

int QGraphicsSceneMoveEvent_QGraphicsSceneMoveEvent_QRegisterMetaType(){qRegisterMetaType<QGraphicsSceneMoveEvent*>(); return qRegisterMetaType<MyQGraphicsSceneMoveEvent*>();}

void* QGraphicsSceneMoveEvent_NewQGraphicsSceneMoveEvent2()
{
	return new MyQGraphicsSceneMoveEvent();
}

void* QGraphicsSceneMoveEvent_NewPos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneMoveEvent*>(ptr)->newPos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneMoveEvent_OldPos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneMoveEvent*>(ptr)->oldPos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QGraphicsSceneMoveEvent_DestroyQGraphicsSceneMoveEvent(void* ptr)
{
	static_cast<QGraphicsSceneMoveEvent*>(ptr)->~QGraphicsSceneMoveEvent();
}

void QGraphicsSceneMoveEvent_DestroyQGraphicsSceneMoveEventDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsSceneResizeEvent: public QGraphicsSceneResizeEvent
{
public:
	MyQGraphicsSceneResizeEvent() : QGraphicsSceneResizeEvent() {QGraphicsSceneResizeEvent_QGraphicsSceneResizeEvent_QRegisterMetaType();};
	 ~MyQGraphicsSceneResizeEvent() { callbackQGraphicsSceneResizeEvent_DestroyQGraphicsSceneResizeEvent(this); };
};

Q_DECLARE_METATYPE(QGraphicsSceneResizeEvent*)
Q_DECLARE_METATYPE(MyQGraphicsSceneResizeEvent*)

int QGraphicsSceneResizeEvent_QGraphicsSceneResizeEvent_QRegisterMetaType(){qRegisterMetaType<QGraphicsSceneResizeEvent*>(); return qRegisterMetaType<MyQGraphicsSceneResizeEvent*>();}

void* QGraphicsSceneResizeEvent_NewQGraphicsSceneResizeEvent2()
{
	return new MyQGraphicsSceneResizeEvent();
}

void* QGraphicsSceneResizeEvent_NewSize(void* ptr)
{
	return ({ QSizeF tmpValue = static_cast<QGraphicsSceneResizeEvent*>(ptr)->newSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsSceneResizeEvent_OldSize(void* ptr)
{
	return ({ QSizeF tmpValue = static_cast<QGraphicsSceneResizeEvent*>(ptr)->oldSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void QGraphicsSceneResizeEvent_DestroyQGraphicsSceneResizeEvent(void* ptr)
{
	static_cast<QGraphicsSceneResizeEvent*>(ptr)->~QGraphicsSceneResizeEvent();
}

void QGraphicsSceneResizeEvent_DestroyQGraphicsSceneResizeEventDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsSceneWheelEvent: public QGraphicsSceneWheelEvent
{
public:
	 ~MyQGraphicsSceneWheelEvent() { callbackQGraphicsSceneWheelEvent_DestroyQGraphicsSceneWheelEvent(this); };
};

Q_DECLARE_METATYPE(QGraphicsSceneWheelEvent*)
Q_DECLARE_METATYPE(MyQGraphicsSceneWheelEvent*)

int QGraphicsSceneWheelEvent_QGraphicsSceneWheelEvent_QRegisterMetaType(){qRegisterMetaType<QGraphicsSceneWheelEvent*>(); return qRegisterMetaType<MyQGraphicsSceneWheelEvent*>();}

long long QGraphicsSceneWheelEvent_Buttons(void* ptr)
{
	return static_cast<QGraphicsSceneWheelEvent*>(ptr)->buttons();
}

int QGraphicsSceneWheelEvent_Delta(void* ptr)
{
	return static_cast<QGraphicsSceneWheelEvent*>(ptr)->delta();
}

long long QGraphicsSceneWheelEvent_Modifiers(void* ptr)
{
	return static_cast<QGraphicsSceneWheelEvent*>(ptr)->modifiers();
}

long long QGraphicsSceneWheelEvent_Orientation(void* ptr)
{
	return static_cast<QGraphicsSceneWheelEvent*>(ptr)->orientation();
}

void* QGraphicsSceneWheelEvent_Pos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneWheelEvent*>(ptr)->pos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneWheelEvent_ScenePos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsSceneWheelEvent*>(ptr)->scenePos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsSceneWheelEvent_ScreenPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QGraphicsSceneWheelEvent*>(ptr)->screenPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QGraphicsSceneWheelEvent_DestroyQGraphicsSceneWheelEvent(void* ptr)
{
	static_cast<QGraphicsSceneWheelEvent*>(ptr)->~QGraphicsSceneWheelEvent();
}

void QGraphicsSceneWheelEvent_DestroyQGraphicsSceneWheelEventDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsSimpleTextItem: public QGraphicsSimpleTextItem
{
public:
	MyQGraphicsSimpleTextItem(QGraphicsItem *parent = Q_NULLPTR) : QGraphicsSimpleTextItem(parent) {QGraphicsSimpleTextItem_QGraphicsSimpleTextItem_QRegisterMetaType();};
	MyQGraphicsSimpleTextItem(const QString &text, QGraphicsItem *parent = Q_NULLPTR) : QGraphicsSimpleTextItem(text, parent) {QGraphicsSimpleTextItem_QGraphicsSimpleTextItem_QRegisterMetaType();};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsSimpleTextItem_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsSimpleTextItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	 ~MyQGraphicsSimpleTextItem() { callbackQGraphicsSimpleTextItem_DestroyQGraphicsSimpleTextItem(this); };
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsSimpleTextItem*)
Q_DECLARE_METATYPE(MyQGraphicsSimpleTextItem*)

int QGraphicsSimpleTextItem_QGraphicsSimpleTextItem_QRegisterMetaType(){qRegisterMetaType<QGraphicsSimpleTextItem*>(); return qRegisterMetaType<MyQGraphicsSimpleTextItem*>();}

void* QGraphicsSimpleTextItem_NewQGraphicsSimpleTextItem(void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsSimpleTextItem(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsSimpleTextItem(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsSimpleTextItem(static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsSimpleTextItem_NewQGraphicsSimpleTextItem2(struct QtWidgets_PackedString text, void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsSimpleTextItem(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsSimpleTextItem(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsSimpleTextItem(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsSimpleTextItem_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsSimpleTextItem*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsSimpleTextItem_BoundingRectDefault(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsSimpleTextItem_Font(void* ptr)
{
	return new QFont(static_cast<QGraphicsSimpleTextItem*>(ptr)->font());
}

void QGraphicsSimpleTextItem_Paint(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsSimpleTextItem*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsSimpleTextItem_PaintDefault(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsSimpleTextItem_SetFont(void* ptr, void* font)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->setFont(*static_cast<QFont*>(font));
}

void QGraphicsSimpleTextItem_SetText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->setText(QString::fromUtf8(text.data, text.len));
}

struct QtWidgets_PackedString QGraphicsSimpleTextItem_Text(void* ptr)
{
	return ({ QByteArray* tb2ceed = new QByteArray(static_cast<QGraphicsSimpleTextItem*>(ptr)->text().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tb2ceed->prepend("WHITESPACE").constData()+10), tb2ceed->size()-10, tb2ceed }; });
}

void QGraphicsSimpleTextItem_DestroyQGraphicsSimpleTextItem(void* ptr)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->~QGraphicsSimpleTextItem();
}

void QGraphicsSimpleTextItem_DestroyQGraphicsSimpleTextItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsTextItem: public QGraphicsTextItem
{
public:
	MyQGraphicsTextItem(QGraphicsItem *parent = Q_NULLPTR) : QGraphicsTextItem(parent) {QGraphicsTextItem_QGraphicsTextItem_QRegisterMetaType();};
	MyQGraphicsTextItem(const QString &text, QGraphicsItem *parent = Q_NULLPTR) : QGraphicsTextItem(text, parent) {QGraphicsTextItem_QGraphicsTextItem_QRegisterMetaType();};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsTextItem_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void Signal_LinkActivated(const QString & link) { QByteArray* t4f0aa5 = new QByteArray(link.toUtf8()); QtWidgets_PackedString linkPacked = { const_cast<char*>(t4f0aa5->prepend("WHITESPACE").constData()+10), t4f0aa5->size()-10, t4f0aa5 };callbackQGraphicsTextItem_LinkActivated(this, linkPacked); };
	void Signal_LinkHovered(const QString & link) { QByteArray* t4f0aa5 = new QByteArray(link.toUtf8()); QtWidgets_PackedString linkPacked = { const_cast<char*>(t4f0aa5->prepend("WHITESPACE").constData()+10), t4f0aa5->size()-10, t4f0aa5 };callbackQGraphicsTextItem_LinkHovered(this, linkPacked); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsTextItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	 ~MyQGraphicsTextItem() { callbackQGraphicsTextItem_DestroyQGraphicsTextItem(this); };
	void Signal_EnabledChanged() { callbackQGraphicsObject_EnabledChanged(this); };
	bool event(QEvent * ev) { return callbackQGraphicsObject_Event(this, ev) != 0; };
	void Signal_OpacityChanged() { callbackQGraphicsObject_OpacityChanged(this); };
	void Signal_ParentChanged() { callbackQGraphicsObject_ParentChanged(this); };
	void Signal_RotationChanged() { callbackQGraphicsObject_RotationChanged(this); };
	void Signal_ScaleChanged() { callbackQGraphicsObject_ScaleChanged(this); };
	void updateMicroFocus() { callbackQGraphicsObject_UpdateMicroFocus(this); };
	void Signal_VisibleChanged() { callbackQGraphicsObject_VisibleChanged(this); };
	void Signal_XChanged() { callbackQGraphicsObject_XChanged(this); };
	void Signal_YChanged() { callbackQGraphicsObject_YChanged(this); };
	void Signal_ZChanged() { callbackQGraphicsObject_ZChanged(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsObject_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsObject_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsObject_TimerEvent(this, event); };
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsTextItem*)
Q_DECLARE_METATYPE(MyQGraphicsTextItem*)

int QGraphicsTextItem_QGraphicsTextItem_QRegisterMetaType(){qRegisterMetaType<QGraphicsTextItem*>(); return qRegisterMetaType<MyQGraphicsTextItem*>();}

void* QGraphicsTextItem_NewQGraphicsTextItem(void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTextItem(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTextItem(static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsTextItem(static_cast<QGraphicsItem*>(parent));
	}
}

void* QGraphicsTextItem_NewQGraphicsTextItem2(struct QtWidgets_PackedString text, void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTextItem(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTextItem(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsWidget*>(parent));
	} else {
		return new MyQGraphicsTextItem(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsItem*>(parent));
	}
}

void QGraphicsTextItem_AdjustSize(void* ptr)
{
	static_cast<QGraphicsTextItem*>(ptr)->adjustSize();
}

void* QGraphicsTextItem_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsTextItem*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsTextItem_BoundingRectDefault(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsTextItem_DefaultTextColor(void* ptr)
{
	return new QColor(static_cast<QGraphicsTextItem*>(ptr)->defaultTextColor());
}

void* QGraphicsTextItem_Document(void* ptr)
{
	return static_cast<QGraphicsTextItem*>(ptr)->document();
}

void* QGraphicsTextItem_Font(void* ptr)
{
	return new QFont(static_cast<QGraphicsTextItem*>(ptr)->font());
}

void QGraphicsTextItem_ConnectLinkActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsTextItem*>(ptr), static_cast<void (QGraphicsTextItem::*)(const QString &)>(&QGraphicsTextItem::linkActivated), static_cast<MyQGraphicsTextItem*>(ptr), static_cast<void (MyQGraphicsTextItem::*)(const QString &)>(&MyQGraphicsTextItem::Signal_LinkActivated), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsTextItem_DisconnectLinkActivated(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsTextItem*>(ptr), static_cast<void (QGraphicsTextItem::*)(const QString &)>(&QGraphicsTextItem::linkActivated), static_cast<MyQGraphicsTextItem*>(ptr), static_cast<void (MyQGraphicsTextItem::*)(const QString &)>(&MyQGraphicsTextItem::Signal_LinkActivated));
}

void QGraphicsTextItem_LinkActivated(void* ptr, struct QtWidgets_PackedString link)
{
	static_cast<QGraphicsTextItem*>(ptr)->linkActivated(QString::fromUtf8(link.data, link.len));
}

void QGraphicsTextItem_ConnectLinkHovered(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsTextItem*>(ptr), static_cast<void (QGraphicsTextItem::*)(const QString &)>(&QGraphicsTextItem::linkHovered), static_cast<MyQGraphicsTextItem*>(ptr), static_cast<void (MyQGraphicsTextItem::*)(const QString &)>(&MyQGraphicsTextItem::Signal_LinkHovered), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsTextItem_DisconnectLinkHovered(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsTextItem*>(ptr), static_cast<void (QGraphicsTextItem::*)(const QString &)>(&QGraphicsTextItem::linkHovered), static_cast<MyQGraphicsTextItem*>(ptr), static_cast<void (MyQGraphicsTextItem::*)(const QString &)>(&MyQGraphicsTextItem::Signal_LinkHovered));
}

void QGraphicsTextItem_LinkHovered(void* ptr, struct QtWidgets_PackedString link)
{
	static_cast<QGraphicsTextItem*>(ptr)->linkHovered(QString::fromUtf8(link.data, link.len));
}

char QGraphicsTextItem_OpenExternalLinks(void* ptr)
{
	return static_cast<QGraphicsTextItem*>(ptr)->openExternalLinks();
}

void QGraphicsTextItem_Paint(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsTextItem*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsTextItem_PaintDefault(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsTextItem_SetDefaultTextColor(void* ptr, void* col)
{
	static_cast<QGraphicsTextItem*>(ptr)->setDefaultTextColor(*static_cast<QColor*>(col));
}

void QGraphicsTextItem_SetDocument(void* ptr, void* document)
{
	static_cast<QGraphicsTextItem*>(ptr)->setDocument(static_cast<QTextDocument*>(document));
}

void QGraphicsTextItem_SetFont(void* ptr, void* font)
{
	static_cast<QGraphicsTextItem*>(ptr)->setFont(*static_cast<QFont*>(font));
}

void QGraphicsTextItem_SetHtml(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QGraphicsTextItem*>(ptr)->setHtml(QString::fromUtf8(text.data, text.len));
}

void QGraphicsTextItem_SetOpenExternalLinks(void* ptr, char open)
{
	static_cast<QGraphicsTextItem*>(ptr)->setOpenExternalLinks(open != 0);
}

void QGraphicsTextItem_SetPlainText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QGraphicsTextItem*>(ptr)->setPlainText(QString::fromUtf8(text.data, text.len));
}

void QGraphicsTextItem_SetTabChangesFocus(void* ptr, char b)
{
	static_cast<QGraphicsTextItem*>(ptr)->setTabChangesFocus(b != 0);
}

void QGraphicsTextItem_SetTextCursor(void* ptr, void* cursor)
{
	static_cast<QGraphicsTextItem*>(ptr)->setTextCursor(*static_cast<QTextCursor*>(cursor));
}

void QGraphicsTextItem_SetTextInteractionFlags(void* ptr, long long flags)
{
	static_cast<QGraphicsTextItem*>(ptr)->setTextInteractionFlags(static_cast<Qt::TextInteractionFlag>(flags));
}

void QGraphicsTextItem_SetTextWidth(void* ptr, double width)
{
	static_cast<QGraphicsTextItem*>(ptr)->setTextWidth(width);
}

char QGraphicsTextItem_TabChangesFocus(void* ptr)
{
	return static_cast<QGraphicsTextItem*>(ptr)->tabChangesFocus();
}

void* QGraphicsTextItem_TextCursor(void* ptr)
{
	return new QTextCursor(static_cast<QGraphicsTextItem*>(ptr)->textCursor());
}

long long QGraphicsTextItem_TextInteractionFlags(void* ptr)
{
	return static_cast<QGraphicsTextItem*>(ptr)->textInteractionFlags();
}

double QGraphicsTextItem_TextWidth(void* ptr)
{
	return static_cast<QGraphicsTextItem*>(ptr)->textWidth();
}

struct QtWidgets_PackedString QGraphicsTextItem_ToHtml(void* ptr)
{
	return ({ QByteArray* t880d4e = new QByteArray(static_cast<QGraphicsTextItem*>(ptr)->toHtml().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t880d4e->prepend("WHITESPACE").constData()+10), t880d4e->size()-10, t880d4e }; });
}

struct QtWidgets_PackedString QGraphicsTextItem_ToPlainText(void* ptr)
{
	return ({ QByteArray* t3e9441 = new QByteArray(static_cast<QGraphicsTextItem*>(ptr)->toPlainText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t3e9441->prepend("WHITESPACE").constData()+10), t3e9441->size()-10, t3e9441 }; });
}

void QGraphicsTextItem_DestroyQGraphicsTextItem(void* ptr)
{
	static_cast<QGraphicsTextItem*>(ptr)->~QGraphicsTextItem();
}

void QGraphicsTextItem_DestroyQGraphicsTextItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGraphicsTransform: public QGraphicsTransform
{
public:
	MyQGraphicsTransform(QObject *parent = Q_NULLPTR) : QGraphicsTransform(parent) {QGraphicsTransform_QGraphicsTransform_QRegisterMetaType();};
	void applyTo(QMatrix4x4 * matrix) const { callbackQGraphicsTransform_ApplyTo(const_cast<void*>(static_cast<const void*>(this)), matrix); };
	void update() { callbackQGraphicsTransform_Update(this); };
	 ~MyQGraphicsTransform() { callbackQGraphicsTransform_DestroyQGraphicsTransform(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsTransform_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsTransform_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsTransform_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsTransform_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsTransform_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsTransform_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsTransform_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsTransform_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsTransform_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsTransform_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsTransform_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsTransform*)
Q_DECLARE_METATYPE(MyQGraphicsTransform*)

int QGraphicsTransform_QGraphicsTransform_QRegisterMetaType(){qRegisterMetaType<QGraphicsTransform*>(); return qRegisterMetaType<MyQGraphicsTransform*>();}

void* QGraphicsTransform_NewQGraphicsTransform(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQGraphicsTransform(static_cast<QWindow*>(parent));
	} else {
		return new MyQGraphicsTransform(static_cast<QObject*>(parent));
	}
}

void QGraphicsTransform_ApplyTo(void* ptr, void* matrix)
{
	static_cast<QGraphicsTransform*>(ptr)->applyTo(static_cast<QMatrix4x4*>(matrix));
}

void QGraphicsTransform_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsTransform*>(ptr), "update");
}

void QGraphicsTransform_UpdateDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsRotation*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::update();
	} else if (dynamic_cast<QGraphicsScale*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::update();
	} else {
		static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::update();
	}
}

void QGraphicsTransform_DestroyQGraphicsTransform(void* ptr)
{
	static_cast<QGraphicsTransform*>(ptr)->~QGraphicsTransform();
}

void QGraphicsTransform_DestroyQGraphicsTransformDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QGraphicsTransform___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsTransform___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QGraphicsTransform___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QGraphicsTransform___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsTransform___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QGraphicsTransform___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsTransform___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void QGraphicsTransform_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsRotation*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QGraphicsScale*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QGraphicsTransform_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QGraphicsRotation*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsScale*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QGraphicsTransform_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsRotation*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsScale*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::customEvent(static_cast<QEvent*>(event));
	}
}

void QGraphicsTransform_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsRotation*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::deleteLater();
	} else if (dynamic_cast<QGraphicsScale*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::deleteLater();
	} else {
		static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::deleteLater();
	}
}

void QGraphicsTransform_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QGraphicsRotation*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsScale*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

char QGraphicsTransform_EventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QGraphicsRotation*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QGraphicsScale*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::event(static_cast<QEvent*>(e));
	} else {
		return static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::event(static_cast<QEvent*>(e));
	}
}

char QGraphicsTransform_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsRotation*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsScale*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void* QGraphicsTransform_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsRotation*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::metaObject());
	} else if (dynamic_cast<QGraphicsScale*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::metaObject());
	}
}

void QGraphicsTransform_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsRotation*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QGraphicsScale*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

class MyQGraphicsView: public QGraphicsView
{
public:
	MyQGraphicsView(QWidget *parent = Q_NULLPTR) : QGraphicsView(parent) {QGraphicsView_QGraphicsView_QRegisterMetaType();};
	MyQGraphicsView(QGraphicsScene *scene, QWidget *parent = Q_NULLPTR) : QGraphicsView(scene, parent) {QGraphicsView_QGraphicsView_QRegisterMetaType();};
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void drawBackground(QPainter * painter, const QRectF & rect) { callbackQGraphicsView_DrawBackground(this, painter, const_cast<QRectF*>(&rect)); };
	void drawForeground(QPainter * painter, const QRectF & rect) { callbackQGraphicsView_DrawForeground(this, painter, const_cast<QRectF*>(&rect)); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void invalidateScene(const QRectF & rect, QGraphicsScene::SceneLayers layers) { callbackQGraphicsView_InvalidateScene(this, const_cast<QRectF*>(&rect), layers); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void Signal_RubberBandChanged(QRect rubberBandRect, QPointF fromScenePoint, QPointF toScenePoint) { callbackQGraphicsView_RubberBandChanged(this, ({ QRect tmpValue = rubberBandRect; new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); }), ({ QPointF tmpValue = fromScenePoint; new QPointF(tmpValue.x(), tmpValue.y()); }), ({ QPointF tmpValue = toScenePoint; new QPointF(tmpValue.x(), tmpValue.y()); })); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * widget) { callbackQGraphicsView_SetupViewport(this, widget); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void updateScene(const QList<QRectF> & rects) { callbackQGraphicsView_UpdateScene(this, ({ QList<QRectF>* tmpValueb7a09e = new QList<QRectF>(rects); QtWidgets_PackedList { tmpValueb7a09e, tmpValueb7a09e->size() }; })); };
	void updateSceneRect(const QRectF & rect) { callbackQGraphicsView_UpdateSceneRect(this, const_cast<QRectF*>(&rect)); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	 ~MyQGraphicsView() { callbackQGraphicsView_DestroyQGraphicsView(this); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsView*)
Q_DECLARE_METATYPE(MyQGraphicsView*)

int QGraphicsView_QGraphicsView_QRegisterMetaType(){qRegisterMetaType<QGraphicsView*>(); return qRegisterMetaType<MyQGraphicsView*>();}

void* QGraphicsView_NewQGraphicsView(void* parent)
{
		return new MyQGraphicsView(static_cast<QWidget*>(parent));
}

void* QGraphicsView_NewQGraphicsView2(void* scene, void* parent)
{
		return new MyQGraphicsView(static_cast<QGraphicsScene*>(scene), static_cast<QWidget*>(parent));
}

long long QGraphicsView_Alignment(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->alignment();
}

void* QGraphicsView_BackgroundBrush(void* ptr)
{
	return new QBrush(static_cast<QGraphicsView*>(ptr)->backgroundBrush());
}

long long QGraphicsView_CacheMode(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->cacheMode();
}

void QGraphicsView_CenterOn(void* ptr, void* pos)
{
	static_cast<QGraphicsView*>(ptr)->centerOn(*static_cast<QPointF*>(pos));
}

void QGraphicsView_CenterOn2(void* ptr, double x, double y)
{
	static_cast<QGraphicsView*>(ptr)->centerOn(x, y);
}

void QGraphicsView_CenterOn3(void* ptr, void* item)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsView*>(ptr)->centerOn(static_cast<QGraphicsObject*>(item));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsView*>(ptr)->centerOn(static_cast<QGraphicsWidget*>(item));
	} else {
		static_cast<QGraphicsView*>(ptr)->centerOn(static_cast<QGraphicsItem*>(item));
	}
}

long long QGraphicsView_DragMode(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->dragMode();
}

void QGraphicsView_DrawBackground(void* ptr, void* painter, void* rect)
{
	static_cast<QGraphicsView*>(ptr)->drawBackground(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect));
}

void QGraphicsView_DrawBackgroundDefault(void* ptr, void* painter, void* rect)
{
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::drawBackground(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect));
}

void QGraphicsView_DrawForeground(void* ptr, void* painter, void* rect)
{
	static_cast<QGraphicsView*>(ptr)->drawForeground(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect));
}

void QGraphicsView_DrawForegroundDefault(void* ptr, void* painter, void* rect)
{
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::drawForeground(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect));
}

void QGraphicsView_EnsureVisible(void* ptr, void* rect, int xmargin, int ymargin)
{
	static_cast<QGraphicsView*>(ptr)->ensureVisible(*static_cast<QRectF*>(rect), xmargin, ymargin);
}

void QGraphicsView_EnsureVisible2(void* ptr, double x, double y, double w, double h, int xmargin, int ymargin)
{
	static_cast<QGraphicsView*>(ptr)->ensureVisible(x, y, w, h, xmargin, ymargin);
}

void QGraphicsView_EnsureVisible3(void* ptr, void* item, int xmargin, int ymargin)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsView*>(ptr)->ensureVisible(static_cast<QGraphicsObject*>(item), xmargin, ymargin);
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsView*>(ptr)->ensureVisible(static_cast<QGraphicsWidget*>(item), xmargin, ymargin);
	} else {
		static_cast<QGraphicsView*>(ptr)->ensureVisible(static_cast<QGraphicsItem*>(item), xmargin, ymargin);
	}
}

void QGraphicsView_FitInView(void* ptr, void* rect, long long aspectRatioMode)
{
	static_cast<QGraphicsView*>(ptr)->fitInView(*static_cast<QRectF*>(rect), static_cast<Qt::AspectRatioMode>(aspectRatioMode));
}

void QGraphicsView_FitInView2(void* ptr, double x, double y, double w, double h, long long aspectRatioMode)
{
	static_cast<QGraphicsView*>(ptr)->fitInView(x, y, w, h, static_cast<Qt::AspectRatioMode>(aspectRatioMode));
}

void QGraphicsView_FitInView3(void* ptr, void* item, long long aspectRatioMode)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsView*>(ptr)->fitInView(static_cast<QGraphicsObject*>(item), static_cast<Qt::AspectRatioMode>(aspectRatioMode));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(item))) {
		static_cast<QGraphicsView*>(ptr)->fitInView(static_cast<QGraphicsWidget*>(item), static_cast<Qt::AspectRatioMode>(aspectRatioMode));
	} else {
		static_cast<QGraphicsView*>(ptr)->fitInView(static_cast<QGraphicsItem*>(item), static_cast<Qt::AspectRatioMode>(aspectRatioMode));
	}
}

void* QGraphicsView_ForegroundBrush(void* ptr)
{
	return new QBrush(static_cast<QGraphicsView*>(ptr)->foregroundBrush());
}

void QGraphicsView_InvalidateScene(void* ptr, void* rect, long long layers)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "invalidateScene", Q_ARG(const QRectF, *static_cast<QRectF*>(rect)), Q_ARG(QGraphicsScene::SceneLayers, static_cast<QGraphicsScene::SceneLayer>(layers)));
}

void QGraphicsView_InvalidateSceneDefault(void* ptr, void* rect, long long layers)
{
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::invalidateScene(*static_cast<QRectF*>(rect), static_cast<QGraphicsScene::SceneLayer>(layers));
}

char QGraphicsView_IsInteractive(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->isInteractive();
}

char QGraphicsView_IsTransformed(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->isTransformed();
}

void* QGraphicsView_ItemAt(void* ptr, void* pos)
{
	return static_cast<QGraphicsView*>(ptr)->itemAt(*static_cast<QPoint*>(pos));
}

void* QGraphicsView_ItemAt2(void* ptr, int x, int y)
{
	return static_cast<QGraphicsView*>(ptr)->itemAt(x, y);
}

struct QtWidgets_PackedList QGraphicsView_Items(void* ptr)
{
	return ({ QList<QGraphicsItem *>* tmpValued1f47c = new QList<QGraphicsItem *>(static_cast<QGraphicsView*>(ptr)->items()); QtWidgets_PackedList { tmpValued1f47c, tmpValued1f47c->size() }; });
}

struct QtWidgets_PackedList QGraphicsView_Items2(void* ptr, void* pos)
{
	return ({ QList<QGraphicsItem *>* tmpValuea914ba = new QList<QGraphicsItem *>(static_cast<QGraphicsView*>(ptr)->items(*static_cast<QPoint*>(pos))); QtWidgets_PackedList { tmpValuea914ba, tmpValuea914ba->size() }; });
}

struct QtWidgets_PackedList QGraphicsView_Items3(void* ptr, int x, int y)
{
	return ({ QList<QGraphicsItem *>* tmpValue429885 = new QList<QGraphicsItem *>(static_cast<QGraphicsView*>(ptr)->items(x, y)); QtWidgets_PackedList { tmpValue429885, tmpValue429885->size() }; });
}

struct QtWidgets_PackedList QGraphicsView_Items4(void* ptr, void* rect, long long mode)
{
	return ({ QList<QGraphicsItem *>* tmpValue4b93fb = new QList<QGraphicsItem *>(static_cast<QGraphicsView*>(ptr)->items(*static_cast<QRect*>(rect), static_cast<Qt::ItemSelectionMode>(mode))); QtWidgets_PackedList { tmpValue4b93fb, tmpValue4b93fb->size() }; });
}

struct QtWidgets_PackedList QGraphicsView_Items5(void* ptr, int x, int y, int w, int h, long long mode)
{
	return ({ QList<QGraphicsItem *>* tmpValue02e509 = new QList<QGraphicsItem *>(static_cast<QGraphicsView*>(ptr)->items(x, y, w, h, static_cast<Qt::ItemSelectionMode>(mode))); QtWidgets_PackedList { tmpValue02e509, tmpValue02e509->size() }; });
}

struct QtWidgets_PackedList QGraphicsView_Items6(void* ptr, void* polygon, long long mode)
{
	return ({ QList<QGraphicsItem *>* tmpValuec2e68e = new QList<QGraphicsItem *>(static_cast<QGraphicsView*>(ptr)->items(*static_cast<QPolygon*>(polygon), static_cast<Qt::ItemSelectionMode>(mode))); QtWidgets_PackedList { tmpValuec2e68e, tmpValuec2e68e->size() }; });
}

struct QtWidgets_PackedList QGraphicsView_Items7(void* ptr, void* path, long long mode)
{
	return ({ QList<QGraphicsItem *>* tmpValuef9fae0 = new QList<QGraphicsItem *>(static_cast<QGraphicsView*>(ptr)->items(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode))); QtWidgets_PackedList { tmpValuef9fae0, tmpValuef9fae0->size() }; });
}

void* QGraphicsView_MapFromScene(void* ptr, void* point)
{
	return ({ QPoint tmpValue = static_cast<QGraphicsView*>(ptr)->mapFromScene(*static_cast<QPointF*>(point)); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsView_MapFromScene2(void* ptr, void* rect)
{
	return new QPolygon(static_cast<QGraphicsView*>(ptr)->mapFromScene(*static_cast<QRectF*>(rect)));
}

void* QGraphicsView_MapFromScene3(void* ptr, void* polygon)
{
	return new QPolygon(static_cast<QGraphicsView*>(ptr)->mapFromScene(*static_cast<QPolygonF*>(polygon)));
}

void* QGraphicsView_MapFromScene4(void* ptr, void* path)
{
	return new QPainterPath(static_cast<QGraphicsView*>(ptr)->mapFromScene(*static_cast<QPainterPath*>(path)));
}

void* QGraphicsView_MapFromScene5(void* ptr, double x, double y)
{
	return ({ QPoint tmpValue = static_cast<QGraphicsView*>(ptr)->mapFromScene(x, y); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsView_MapFromScene6(void* ptr, double x, double y, double w, double h)
{
	return new QPolygon(static_cast<QGraphicsView*>(ptr)->mapFromScene(x, y, w, h));
}

void* QGraphicsView_MapToScene(void* ptr, void* point)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsView*>(ptr)->mapToScene(*static_cast<QPoint*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsView_MapToScene2(void* ptr, void* rect)
{
	return new QPolygonF(static_cast<QGraphicsView*>(ptr)->mapToScene(*static_cast<QRect*>(rect)));
}

void* QGraphicsView_MapToScene3(void* ptr, void* polygon)
{
	return new QPolygonF(static_cast<QGraphicsView*>(ptr)->mapToScene(*static_cast<QPolygon*>(polygon)));
}

void* QGraphicsView_MapToScene4(void* ptr, void* path)
{
	return new QPainterPath(static_cast<QGraphicsView*>(ptr)->mapToScene(*static_cast<QPainterPath*>(path)));
}

void* QGraphicsView_MapToScene5(void* ptr, int x, int y)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsView*>(ptr)->mapToScene(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsView_MapToScene6(void* ptr, int x, int y, int w, int h)
{
	return new QPolygonF(static_cast<QGraphicsView*>(ptr)->mapToScene(x, y, w, h));
}

void* QGraphicsView_Matrix(void* ptr)
{
	return new QMatrix(static_cast<QGraphicsView*>(ptr)->matrix());
}

long long QGraphicsView_OptimizationFlags(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->optimizationFlags();
}

void QGraphicsView_Render(void* ptr, void* painter, void* target, void* source, long long aspectRatioMode)
{
	static_cast<QGraphicsView*>(ptr)->render(static_cast<QPainter*>(painter), *static_cast<QRectF*>(target), *static_cast<QRect*>(source), static_cast<Qt::AspectRatioMode>(aspectRatioMode));
}

long long QGraphicsView_RenderHints(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->renderHints();
}

void QGraphicsView_ResetCachedContent(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->resetCachedContent();
}

void QGraphicsView_ResetMatrix(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->resetMatrix();
}

void QGraphicsView_ResetTransform(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->resetTransform();
}

long long QGraphicsView_ResizeAnchor(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->resizeAnchor();
}

void QGraphicsView_Rotate(void* ptr, double angle)
{
	static_cast<QGraphicsView*>(ptr)->rotate(angle);
}

void QGraphicsView_ConnectRubberBandChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsView*>(ptr), static_cast<void (QGraphicsView::*)(QRect, QPointF, QPointF)>(&QGraphicsView::rubberBandChanged), static_cast<MyQGraphicsView*>(ptr), static_cast<void (MyQGraphicsView::*)(QRect, QPointF, QPointF)>(&MyQGraphicsView::Signal_RubberBandChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsView_DisconnectRubberBandChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsView*>(ptr), static_cast<void (QGraphicsView::*)(QRect, QPointF, QPointF)>(&QGraphicsView::rubberBandChanged), static_cast<MyQGraphicsView*>(ptr), static_cast<void (MyQGraphicsView::*)(QRect, QPointF, QPointF)>(&MyQGraphicsView::Signal_RubberBandChanged));
}

void QGraphicsView_RubberBandChanged(void* ptr, void* rubberBandRect, void* fromScenePoint, void* toScenePoint)
{
	static_cast<QGraphicsView*>(ptr)->rubberBandChanged(*static_cast<QRect*>(rubberBandRect), *static_cast<QPointF*>(fromScenePoint), *static_cast<QPointF*>(toScenePoint));
}

void* QGraphicsView_RubberBandRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QGraphicsView*>(ptr)->rubberBandRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

long long QGraphicsView_RubberBandSelectionMode(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->rubberBandSelectionMode();
}

void QGraphicsView_Scale(void* ptr, double sx, double sy)
{
	static_cast<QGraphicsView*>(ptr)->scale(sx, sy);
}

void* QGraphicsView_Scene(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->scene();
}

void* QGraphicsView_SceneRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsView*>(ptr)->sceneRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsView_SetAlignment(void* ptr, long long alignment)
{
	static_cast<QGraphicsView*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}

void QGraphicsView_SetBackgroundBrush(void* ptr, void* brush)
{
	static_cast<QGraphicsView*>(ptr)->setBackgroundBrush(*static_cast<QBrush*>(brush));
}

void QGraphicsView_SetCacheMode(void* ptr, long long mode)
{
	static_cast<QGraphicsView*>(ptr)->setCacheMode(static_cast<QGraphicsView::CacheModeFlag>(mode));
}

void QGraphicsView_SetDragMode(void* ptr, long long mode)
{
	static_cast<QGraphicsView*>(ptr)->setDragMode(static_cast<QGraphicsView::DragMode>(mode));
}

void QGraphicsView_SetForegroundBrush(void* ptr, void* brush)
{
	static_cast<QGraphicsView*>(ptr)->setForegroundBrush(*static_cast<QBrush*>(brush));
}

void QGraphicsView_SetInteractive(void* ptr, char allowed)
{
	static_cast<QGraphicsView*>(ptr)->setInteractive(allowed != 0);
}

void QGraphicsView_SetMatrix(void* ptr, void* matrix, char combine)
{
	static_cast<QGraphicsView*>(ptr)->setMatrix(*static_cast<QMatrix*>(matrix), combine != 0);
}

void QGraphicsView_SetOptimizationFlag(void* ptr, long long flag, char enabled)
{
	static_cast<QGraphicsView*>(ptr)->setOptimizationFlag(static_cast<QGraphicsView::OptimizationFlag>(flag), enabled != 0);
}

void QGraphicsView_SetOptimizationFlags(void* ptr, long long flags)
{
	static_cast<QGraphicsView*>(ptr)->setOptimizationFlags(static_cast<QGraphicsView::OptimizationFlag>(flags));
}

void QGraphicsView_SetRenderHint(void* ptr, long long hint, char enabled)
{
	static_cast<QGraphicsView*>(ptr)->setRenderHint(static_cast<QPainter::RenderHint>(hint), enabled != 0);
}

void QGraphicsView_SetRenderHints(void* ptr, long long hints)
{
	static_cast<QGraphicsView*>(ptr)->setRenderHints(static_cast<QPainter::RenderHint>(hints));
}

void QGraphicsView_SetResizeAnchor(void* ptr, long long anchor)
{
	static_cast<QGraphicsView*>(ptr)->setResizeAnchor(static_cast<QGraphicsView::ViewportAnchor>(anchor));
}

void QGraphicsView_SetRubberBandSelectionMode(void* ptr, long long mode)
{
	static_cast<QGraphicsView*>(ptr)->setRubberBandSelectionMode(static_cast<Qt::ItemSelectionMode>(mode));
}

void QGraphicsView_SetScene(void* ptr, void* scene)
{
	static_cast<QGraphicsView*>(ptr)->setScene(static_cast<QGraphicsScene*>(scene));
}

void QGraphicsView_SetSceneRect(void* ptr, void* rect)
{
	static_cast<QGraphicsView*>(ptr)->setSceneRect(*static_cast<QRectF*>(rect));
}

void QGraphicsView_SetSceneRect2(void* ptr, double x, double y, double w, double h)
{
	static_cast<QGraphicsView*>(ptr)->setSceneRect(x, y, w, h);
}

void QGraphicsView_SetTransform(void* ptr, void* matrix, char combine)
{
	static_cast<QGraphicsView*>(ptr)->setTransform(*static_cast<QTransform*>(matrix), combine != 0);
}

void QGraphicsView_SetTransformationAnchor(void* ptr, long long anchor)
{
	static_cast<QGraphicsView*>(ptr)->setTransformationAnchor(static_cast<QGraphicsView::ViewportAnchor>(anchor));
}

void QGraphicsView_SetViewportUpdateMode(void* ptr, long long mode)
{
	static_cast<QGraphicsView*>(ptr)->setViewportUpdateMode(static_cast<QGraphicsView::ViewportUpdateMode>(mode));
}

void QGraphicsView_SetupViewport(void* ptr, void* widget)
{
		QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "setupViewport", Q_ARG(QWidget*, static_cast<QWidget*>(widget)));
}

void QGraphicsView_SetupViewportDefault(void* ptr, void* widget)
{
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::setupViewport(static_cast<QWidget*>(widget));
}

void QGraphicsView_Shear(void* ptr, double sh, double sv)
{
	static_cast<QGraphicsView*>(ptr)->shear(sh, sv);
}

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

long long QGraphicsView_TransformationAnchor(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->transformationAnchor();
}

void QGraphicsView_Translate(void* ptr, double dx, double dy)
{
	static_cast<QGraphicsView*>(ptr)->translate(dx, dy);
}

void QGraphicsView_UpdateScene(void* ptr, void* rects)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "updateScene", Q_ARG(const QList<QRectF>, *static_cast<QList<QRectF>*>(rects)));
}

void QGraphicsView_UpdateSceneDefault(void* ptr, void* rects)
{
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::updateScene(*static_cast<QList<QRectF>*>(rects));
}

void QGraphicsView_UpdateSceneRect(void* ptr, void* rect)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "updateSceneRect", Q_ARG(const QRectF, *static_cast<QRectF*>(rect)));
}

void QGraphicsView_UpdateSceneRectDefault(void* ptr, void* rect)
{
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::updateSceneRect(*static_cast<QRectF*>(rect));
}

void* QGraphicsView_ViewportTransform(void* ptr)
{
	return new QTransform(static_cast<QGraphicsView*>(ptr)->viewportTransform());
}

long long QGraphicsView_ViewportUpdateMode(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->viewportUpdateMode();
}

void QGraphicsView_DestroyQGraphicsView(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->~QGraphicsView();
}

void QGraphicsView_DestroyQGraphicsViewDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QGraphicsView___items_atList(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsView___items_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsView___items_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsView___items_atList2(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsView___items_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsView___items_newList2(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsView___items_atList3(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsView___items_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsView___items_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsView___items_atList4(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsView___items_setList4(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsView___items_newList4(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsView___items_atList5(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsView___items_setList5(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsView___items_newList5(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsView___items_atList6(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsView___items_setList6(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsView___items_newList6(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsView___items_atList7(void* ptr, int i)
{
	return ({QGraphicsItem * tmp = static_cast<QList<QGraphicsItem *>*>(ptr)->at(i); if (i == static_cast<QList<QGraphicsItem *>*>(ptr)->size()-1) { static_cast<QList<QGraphicsItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QGraphicsView___items_setList7(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else {
		static_cast<QList<QGraphicsItem *>*>(ptr)->append(static_cast<QGraphicsItem*>(i));
	}
}

void* QGraphicsView___items_newList7(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QGraphicsItem *>();
}

void* QGraphicsView___updateScene_rects_atList(void* ptr, int i)
{
	return ({ QRectF tmpValue = ({QRectF tmp = static_cast<QList<QRectF>*>(ptr)->at(i); if (i == static_cast<QList<QRectF>*>(ptr)->size()-1) { static_cast<QList<QRectF>*>(ptr)->~QList(); free(ptr); }; tmp; }); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

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

void* QGraphicsView___updateScene_rects_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QRectF>();
}

class MyQGraphicsWidget: public QGraphicsWidget
{
public:
	MyQGraphicsWidget(QGraphicsItem *parent = Q_NULLPTR, Qt::WindowFlags wFlags = Qt::WindowFlags()) : QGraphicsWidget(parent, wFlags) {QGraphicsWidget_QGraphicsWidget_QRegisterMetaType();};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsWidget_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
	void changeEvent(QEvent * event) { callbackQGraphicsWidget_ChangeEvent(this, event); };
	bool close() { return callbackQGraphicsWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQGraphicsWidget_CloseEvent(this, event); };
	bool event(QEvent * event) { return callbackQGraphicsObject_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQGraphicsWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, event); };
	void Signal_GeometryChanged() { callbackQGraphicsWidget_GeometryChanged(this); };
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsLayoutItem_GetContentsMargins(const_cast<void*>(static_cast<const void*>(this)), *left, *top, *right, *bottom); };
	void grabKeyboardEvent(QEvent * event) { callbackQGraphicsWidget_GrabKeyboardEvent(this, event); };
	void grabMouseEvent(QEvent * event) { callbackQGraphicsWidget_GrabMouseEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQGraphicsWidget_HideEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, event); };
	void initStyleOption(QStyleOption * option) const { callbackQGraphicsWidget_InitStyleOption(const_cast<void*>(static_cast<const void*>(this)), option); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void Signal_LayoutChanged() { callbackQGraphicsWidget_LayoutChanged(this); };
	void moveEvent(QGraphicsSceneMoveEvent * event) { callbackQGraphicsWidget_MoveEvent(this, event); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsWidget_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	void paintWindowFrame(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsWidget_PaintWindowFrame(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	void polishEvent() { callbackQGraphicsWidget_PolishEvent(this); };
	void resizeEvent(QGraphicsSceneResizeEvent * event) { callbackQGraphicsWidget_ResizeEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, event) != 0; };
	void setGeometry(const QRectF & rect) { callbackQGraphicsLayoutItem_SetGeometry(this, const_cast<QRectF*>(&rect)); };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<void*>(static_cast<const void*>(this)))); };
	void showEvent(QShowEvent * event) { callbackQGraphicsWidget_ShowEvent(this, event); };
	QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)), which, const_cast<QSizeF*>(&constraint))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	void ungrabKeyboardEvent(QEvent * event) { callbackQGraphicsWidget_UngrabKeyboardEvent(this, event); };
	void ungrabMouseEvent(QEvent * event) { callbackQGraphicsWidget_UngrabMouseEvent(this, event); };
	void updateGeometry() { callbackQGraphicsLayoutItem_UpdateGeometry(this); };
	bool windowFrameEvent(QEvent * event) { return callbackQGraphicsWidget_WindowFrameEvent(this, event) != 0; };
	Qt::WindowFrameSection windowFrameSectionAt(const QPointF & pos) const { return static_cast<Qt::WindowFrameSection>(callbackQGraphicsWidget_WindowFrameSectionAt(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&pos))); };
	 ~MyQGraphicsWidget() { callbackQGraphicsWidget_DestroyQGraphicsWidget(this); };
	void Signal_EnabledChanged() { callbackQGraphicsObject_EnabledChanged(this); };
	void Signal_OpacityChanged() { callbackQGraphicsObject_OpacityChanged(this); };
	void Signal_ParentChanged() { callbackQGraphicsObject_ParentChanged(this); };
	void Signal_RotationChanged() { callbackQGraphicsObject_RotationChanged(this); };
	void Signal_ScaleChanged() { callbackQGraphicsObject_ScaleChanged(this); };
	void updateMicroFocus() { callbackQGraphicsObject_UpdateMicroFocus(this); };
	void Signal_VisibleChanged() { callbackQGraphicsObject_VisibleChanged(this); };
	void Signal_XChanged() { callbackQGraphicsObject_XChanged(this); };
	void Signal_YChanged() { callbackQGraphicsObject_YChanged(this); };
	void Signal_ZChanged() { callbackQGraphicsObject_ZChanged(this); };
	void childEvent(QChildEvent * event) { callbackQGraphicsObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsObject_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGraphicsObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsObject_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGraphicsObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsObject_TimerEvent(this, event); };
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPainterPath*>(&path), mode) != 0; };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point)) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QGraphicsItem*>(item)) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, event); };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<void*>(static_cast<const void*>(this)))); };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
};

Q_DECLARE_METATYPE(QGraphicsWidget*)
Q_DECLARE_METATYPE(MyQGraphicsWidget*)

int QGraphicsWidget_QGraphicsWidget_QRegisterMetaType(){qRegisterMetaType<QGraphicsWidget*>(); return qRegisterMetaType<MyQGraphicsWidget*>();}

void* QGraphicsWidget_NewQGraphicsWidget(void* parent, long long wFlags)
{
	return new MyQGraphicsWidget(static_cast<QGraphicsItem*>(parent), static_cast<Qt::WindowType>(wFlags));
}

struct QtWidgets_PackedList QGraphicsWidget_Actions(void* ptr)
{
		return ({ QList<QAction *>* tmpValuec4928c = new QList<QAction *>(static_cast<QGraphicsWidget*>(ptr)->actions()); QtWidgets_PackedList { tmpValuec4928c, tmpValuec4928c->size() }; });
}

void QGraphicsWidget_AddAction(void* ptr, void* action)
{
		static_cast<QGraphicsWidget*>(ptr)->addAction(static_cast<QAction*>(action));
}

void QGraphicsWidget_AddActions(void* ptr, void* actions)
{
		static_cast<QGraphicsWidget*>(ptr)->addActions(({ QList<QAction *>* tmpP = static_cast<QList<QAction *>*>(actions); QList<QAction *> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
}

void QGraphicsWidget_AdjustSize(void* ptr)
{
		static_cast<QGraphicsWidget*>(ptr)->adjustSize();
}

char QGraphicsWidget_AutoFillBackground(void* ptr)
{
		return static_cast<QGraphicsWidget*>(ptr)->autoFillBackground();
}

void* QGraphicsWidget_BoundingRect(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsWidget_BoundingRectDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRectF tmpValue = static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void QGraphicsWidget_ChangeEvent(void* ptr, void* event)
{
		static_cast<QGraphicsWidget*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QGraphicsWidget_ChangeEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::changeEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::changeEvent(static_cast<QEvent*>(event));
	}
}

char QGraphicsWidget_Close(void* ptr)
{
		bool returnArg;
	QMetaObject::invokeMethod(static_cast<QGraphicsWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QGraphicsWidget_CloseDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::close();
	} else {
		return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::close();
	}
}

void QGraphicsWidget_CloseEvent(void* ptr, void* event)
{
		static_cast<QGraphicsWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QGraphicsWidget_CloseEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::closeEvent(static_cast<QCloseEvent*>(event));
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::closeEvent(static_cast<QCloseEvent*>(event));
	}
}

char QGraphicsWidget_FocusNextPrevChild(void* ptr, char next)
{
		return static_cast<QGraphicsWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QGraphicsWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::focusNextPrevChild(next != 0);
	} else {
		return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::focusNextPrevChild(next != 0);
	}
}

long long QGraphicsWidget_FocusPolicy(void* ptr)
{
		return static_cast<QGraphicsWidget*>(ptr)->focusPolicy();
}

void* QGraphicsWidget_FocusWidget(void* ptr)
{
		return static_cast<QGraphicsWidget*>(ptr)->focusWidget();
}

void* QGraphicsWidget_Font(void* ptr)
{
		return new QFont(static_cast<QGraphicsWidget*>(ptr)->font());
}

void QGraphicsWidget_ConnectGeometryChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsWidget*>(ptr), static_cast<void (QGraphicsWidget::*)()>(&QGraphicsWidget::geometryChanged), static_cast<MyQGraphicsWidget*>(ptr), static_cast<void (MyQGraphicsWidget::*)()>(&MyQGraphicsWidget::Signal_GeometryChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsWidget_DisconnectGeometryChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsWidget*>(ptr), static_cast<void (QGraphicsWidget::*)()>(&QGraphicsWidget::geometryChanged), static_cast<MyQGraphicsWidget*>(ptr), static_cast<void (MyQGraphicsWidget::*)()>(&MyQGraphicsWidget::Signal_GeometryChanged));
}

void QGraphicsWidget_GeometryChanged(void* ptr)
{
		static_cast<QGraphicsWidget*>(ptr)->geometryChanged();
}

void QGraphicsWidget_GetWindowFrameMargins(void* ptr, double left, double top, double right, double bottom)
{
		static_cast<QGraphicsWidget*>(ptr)->getWindowFrameMargins(&left, &top, &right, &bottom);
}

void QGraphicsWidget_GrabKeyboardEvent(void* ptr, void* event)
{
		static_cast<QGraphicsWidget*>(ptr)->grabKeyboardEvent(static_cast<QEvent*>(event));
}

void QGraphicsWidget_GrabKeyboardEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::grabKeyboardEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::grabKeyboardEvent(static_cast<QEvent*>(event));
	}
}

void QGraphicsWidget_GrabMouseEvent(void* ptr, void* event)
{
		static_cast<QGraphicsWidget*>(ptr)->grabMouseEvent(static_cast<QEvent*>(event));
}

void QGraphicsWidget_GrabMouseEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::grabMouseEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::grabMouseEvent(static_cast<QEvent*>(event));
	}
}

int QGraphicsWidget_GrabShortcut(void* ptr, void* sequence, long long context)
{
		return static_cast<QGraphicsWidget*>(ptr)->grabShortcut(*static_cast<QKeySequence*>(sequence), static_cast<Qt::ShortcutContext>(context));
}

void QGraphicsWidget_HideEvent(void* ptr, void* event)
{
		static_cast<QGraphicsWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QGraphicsWidget_HideEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::hideEvent(static_cast<QHideEvent*>(event));
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::hideEvent(static_cast<QHideEvent*>(event));
	}
}

void QGraphicsWidget_InitStyleOption(void* ptr, void* option)
{
		static_cast<QGraphicsWidget*>(ptr)->initStyleOption(static_cast<QStyleOption*>(option));
}

void QGraphicsWidget_InitStyleOptionDefault(void* ptr, void* option)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::initStyleOption(static_cast<QStyleOption*>(option));
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::initStyleOption(static_cast<QStyleOption*>(option));
	}
}

void QGraphicsWidget_InsertAction(void* ptr, void* before, void* action)
{
		static_cast<QGraphicsWidget*>(ptr)->insertAction(static_cast<QAction*>(before), static_cast<QAction*>(action));
}

void QGraphicsWidget_InsertActions(void* ptr, void* before, void* actions)
{
		static_cast<QGraphicsWidget*>(ptr)->insertActions(static_cast<QAction*>(before), ({ QList<QAction *>* tmpP = static_cast<QList<QAction *>*>(actions); QList<QAction *> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
}

char QGraphicsWidget_IsActiveWindow(void* ptr)
{
		return static_cast<QGraphicsWidget*>(ptr)->isActiveWindow();
}

void* QGraphicsWidget_Layout(void* ptr)
{
		return static_cast<QGraphicsWidget*>(ptr)->layout();
}

void QGraphicsWidget_ConnectLayoutChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QGraphicsWidget*>(ptr), static_cast<void (QGraphicsWidget::*)()>(&QGraphicsWidget::layoutChanged), static_cast<MyQGraphicsWidget*>(ptr), static_cast<void (MyQGraphicsWidget::*)()>(&MyQGraphicsWidget::Signal_LayoutChanged), static_cast<Qt::ConnectionType>(t));
}

void QGraphicsWidget_DisconnectLayoutChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGraphicsWidget*>(ptr), static_cast<void (QGraphicsWidget::*)()>(&QGraphicsWidget::layoutChanged), static_cast<MyQGraphicsWidget*>(ptr), static_cast<void (MyQGraphicsWidget::*)()>(&MyQGraphicsWidget::Signal_LayoutChanged));
}

void QGraphicsWidget_LayoutChanged(void* ptr)
{
		static_cast<QGraphicsWidget*>(ptr)->layoutChanged();
}

long long QGraphicsWidget_LayoutDirection(void* ptr)
{
		return static_cast<QGraphicsWidget*>(ptr)->layoutDirection();
}

void QGraphicsWidget_MoveEvent(void* ptr, void* event)
{
		static_cast<QGraphicsWidget*>(ptr)->moveEvent(static_cast<QGraphicsSceneMoveEvent*>(event));
}

void QGraphicsWidget_MoveEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::moveEvent(static_cast<QGraphicsSceneMoveEvent*>(event));
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::moveEvent(static_cast<QGraphicsSceneMoveEvent*>(event));
	}
}

void QGraphicsWidget_Paint(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsWidget*>(ptr)->paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsWidget_PaintDefault(void* ptr, void* painter, void* option, void* widget)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::paint(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	}
}

void QGraphicsWidget_PaintWindowFrame(void* ptr, void* painter, void* option, void* widget)
{
		static_cast<QGraphicsWidget*>(ptr)->paintWindowFrame(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsWidget_PaintWindowFrameDefault(void* ptr, void* painter, void* option, void* widget)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::paintWindowFrame(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::paintWindowFrame(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
	}
}

void* QGraphicsWidget_Palette(void* ptr)
{
		return new QPalette(static_cast<QGraphicsWidget*>(ptr)->palette());
}

void QGraphicsWidget_PolishEvent(void* ptr)
{
		static_cast<QGraphicsWidget*>(ptr)->polishEvent();
}

void QGraphicsWidget_PolishEventDefault(void* ptr)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::polishEvent();
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::polishEvent();
	}
}

void* QGraphicsWidget_Rect(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->rect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsWidget_ReleaseShortcut(void* ptr, int id)
{
		static_cast<QGraphicsWidget*>(ptr)->releaseShortcut(id);
}

void QGraphicsWidget_RemoveAction(void* ptr, void* action)
{
		static_cast<QGraphicsWidget*>(ptr)->removeAction(static_cast<QAction*>(action));
}

void QGraphicsWidget_Resize(void* ptr, void* size)
{
		static_cast<QGraphicsWidget*>(ptr)->resize(*static_cast<QSizeF*>(size));
}

void QGraphicsWidget_Resize2(void* ptr, double w, double h)
{
		static_cast<QGraphicsWidget*>(ptr)->resize(w, h);
}

void QGraphicsWidget_ResizeEvent(void* ptr, void* event)
{
		static_cast<QGraphicsWidget*>(ptr)->resizeEvent(static_cast<QGraphicsSceneResizeEvent*>(event));
}

void QGraphicsWidget_ResizeEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::resizeEvent(static_cast<QGraphicsSceneResizeEvent*>(event));
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::resizeEvent(static_cast<QGraphicsSceneResizeEvent*>(event));
	}
}

void QGraphicsWidget_SetAttribute(void* ptr, long long attribute, char on)
{
		static_cast<QGraphicsWidget*>(ptr)->setAttribute(static_cast<Qt::WidgetAttribute>(attribute), on != 0);
}

void QGraphicsWidget_SetAutoFillBackground(void* ptr, char enabled)
{
		static_cast<QGraphicsWidget*>(ptr)->setAutoFillBackground(enabled != 0);
}

void QGraphicsWidget_SetContentsMargins(void* ptr, double left, double top, double right, double bottom)
{
		static_cast<QGraphicsWidget*>(ptr)->setContentsMargins(left, top, right, bottom);
}

void QGraphicsWidget_SetFocusPolicy(void* ptr, long long policy)
{
		static_cast<QGraphicsWidget*>(ptr)->setFocusPolicy(static_cast<Qt::FocusPolicy>(policy));
}

void QGraphicsWidget_SetFont(void* ptr, void* font)
{
		static_cast<QGraphicsWidget*>(ptr)->setFont(*static_cast<QFont*>(font));
}

void QGraphicsWidget_SetGeometry2(void* ptr, double x, double y, double w, double h)
{
		static_cast<QGraphicsWidget*>(ptr)->setGeometry(x, y, w, h);
}

void QGraphicsWidget_SetLayout(void* ptr, void* layout)
{
		static_cast<QGraphicsWidget*>(ptr)->setLayout(static_cast<QGraphicsLayout*>(layout));
}

void QGraphicsWidget_SetLayoutDirection(void* ptr, long long direction)
{
		static_cast<QGraphicsWidget*>(ptr)->setLayoutDirection(static_cast<Qt::LayoutDirection>(direction));
}

void QGraphicsWidget_SetPalette(void* ptr, void* palette)
{
		static_cast<QGraphicsWidget*>(ptr)->setPalette(*static_cast<QPalette*>(palette));
}

void QGraphicsWidget_SetShortcutAutoRepeat(void* ptr, int id, char enabled)
{
		static_cast<QGraphicsWidget*>(ptr)->setShortcutAutoRepeat(id, enabled != 0);
}

void QGraphicsWidget_SetShortcutEnabled(void* ptr, int id, char enabled)
{
		static_cast<QGraphicsWidget*>(ptr)->setShortcutEnabled(id, enabled != 0);
}

void QGraphicsWidget_SetStyle(void* ptr, void* style)
{
		static_cast<QGraphicsWidget*>(ptr)->setStyle(static_cast<QStyle*>(style));
}

void QGraphicsWidget_QGraphicsWidget_SetTabOrder(void* first, void* second)
{
		QGraphicsWidget::setTabOrder(static_cast<QGraphicsWidget*>(first), static_cast<QGraphicsWidget*>(second));
}

void QGraphicsWidget_SetWindowFlags(void* ptr, long long wFlags)
{
		static_cast<QGraphicsWidget*>(ptr)->setWindowFlags(static_cast<Qt::WindowType>(wFlags));
}

void QGraphicsWidget_SetWindowFrameMargins(void* ptr, double left, double top, double right, double bottom)
{
		static_cast<QGraphicsWidget*>(ptr)->setWindowFrameMargins(left, top, right, bottom);
}

void QGraphicsWidget_SetWindowTitle(void* ptr, struct QtWidgets_PackedString title)
{
		static_cast<QGraphicsWidget*>(ptr)->setWindowTitle(QString::fromUtf8(title.data, title.len));
}

void QGraphicsWidget_ShowEvent(void* ptr, void* event)
{
		static_cast<QGraphicsWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QGraphicsWidget_ShowEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::showEvent(static_cast<QShowEvent*>(event));
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::showEvent(static_cast<QShowEvent*>(event));
	}
}

void* QGraphicsWidget_Size(void* ptr)
{
		return ({ QSizeF tmpValue = static_cast<QGraphicsWidget*>(ptr)->size(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsWidget_SizeHint(void* ptr, long long which, void* constraint)
{
		return ({ QSizeF tmpValue = static_cast<QGraphicsWidget*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsWidget_SizeHintDefault(void* ptr, long long which, void* constraint)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSizeF tmpValue = static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSizeF tmpValue = static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
	}
}

void* QGraphicsWidget_Style(void* ptr)
{
		return static_cast<QGraphicsWidget*>(ptr)->style();
}

char QGraphicsWidget_TestAttribute(void* ptr, long long attribute)
{
		return static_cast<QGraphicsWidget*>(ptr)->testAttribute(static_cast<Qt::WidgetAttribute>(attribute));
}

void QGraphicsWidget_UngrabKeyboardEvent(void* ptr, void* event)
{
		static_cast<QGraphicsWidget*>(ptr)->ungrabKeyboardEvent(static_cast<QEvent*>(event));
}

void QGraphicsWidget_UngrabKeyboardEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::ungrabKeyboardEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::ungrabKeyboardEvent(static_cast<QEvent*>(event));
	}
}

void QGraphicsWidget_UngrabMouseEvent(void* ptr, void* event)
{
		static_cast<QGraphicsWidget*>(ptr)->ungrabMouseEvent(static_cast<QEvent*>(event));
}

void QGraphicsWidget_UngrabMouseEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::ungrabMouseEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::ungrabMouseEvent(static_cast<QEvent*>(event));
	}
}

void QGraphicsWidget_UnsetLayoutDirection(void* ptr)
{
		static_cast<QGraphicsWidget*>(ptr)->unsetLayoutDirection();
}

void QGraphicsWidget_UnsetWindowFrameMargins(void* ptr)
{
		static_cast<QGraphicsWidget*>(ptr)->unsetWindowFrameMargins();
}

long long QGraphicsWidget_WindowFlags(void* ptr)
{
		return static_cast<QGraphicsWidget*>(ptr)->windowFlags();
}

char QGraphicsWidget_WindowFrameEvent(void* ptr, void* event)
{
		return static_cast<QGraphicsWidget*>(ptr)->windowFrameEvent(static_cast<QEvent*>(event));
}

char QGraphicsWidget_WindowFrameEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::windowFrameEvent(static_cast<QEvent*>(event));
	} else {
		return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::windowFrameEvent(static_cast<QEvent*>(event));
	}
}

void* QGraphicsWidget_WindowFrameGeometry(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->windowFrameGeometry(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsWidget_WindowFrameRect(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->windowFrameRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

long long QGraphicsWidget_WindowFrameSectionAt(void* ptr, void* pos)
{
		return static_cast<QGraphicsWidget*>(ptr)->windowFrameSectionAt(*static_cast<QPointF*>(pos));
}

long long QGraphicsWidget_WindowFrameSectionAtDefault(void* ptr, void* pos)
{
	if (dynamic_cast<QGraphicsProxyWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::windowFrameSectionAt(*static_cast<QPointF*>(pos));
	} else {
		return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::windowFrameSectionAt(*static_cast<QPointF*>(pos));
	}
}

struct QtWidgets_PackedString QGraphicsWidget_WindowTitle(void* ptr)
{
		return ({ QByteArray* t8cb41d = new QByteArray(static_cast<QGraphicsWidget*>(ptr)->windowTitle().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t8cb41d->prepend("WHITESPACE").constData()+10), t8cb41d->size()-10, t8cb41d }; });
}

long long QGraphicsWidget_WindowType(void* ptr)
{
		return static_cast<QGraphicsWidget*>(ptr)->windowType();
}

void QGraphicsWidget_DestroyQGraphicsWidget(void* ptr)
{
	static_cast<QGraphicsWidget*>(ptr)->~QGraphicsWidget();
}

void QGraphicsWidget_DestroyQGraphicsWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QGraphicsWidget_MinimumSize(void* ptr)
{
		return ({ QSizeF tmpValue = static_cast<QGraphicsWidget*>(ptr)->minimumSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void QGraphicsWidget_SetMinimumSize(void* ptr, void* minimumSize)
{
		static_cast<QGraphicsWidget*>(ptr)->setMinimumSize(*static_cast<QSizeF*>(minimumSize));
}

void* QGraphicsWidget_PreferredSize(void* ptr)
{
		return ({ QSizeF tmpValue = static_cast<QGraphicsWidget*>(ptr)->preferredSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void QGraphicsWidget_SetPreferredSize(void* ptr, void* preferredSize)
{
		static_cast<QGraphicsWidget*>(ptr)->setPreferredSize(*static_cast<QSizeF*>(preferredSize));
}

void* QGraphicsWidget_MaximumSize(void* ptr)
{
		return ({ QSizeF tmpValue = static_cast<QGraphicsWidget*>(ptr)->maximumSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void QGraphicsWidget_SetMaximumSize(void* ptr, void* maximumSize)
{
		static_cast<QGraphicsWidget*>(ptr)->setMaximumSize(*static_cast<QSizeF*>(maximumSize));
}

void* QGraphicsWidget_SizePolicy(void* ptr)
{
		return new QSizePolicy(static_cast<QGraphicsWidget*>(ptr)->sizePolicy());
}

void QGraphicsWidget_SetSizePolicy(void* ptr, void* sizePolicy)
{
		static_cast<QGraphicsWidget*>(ptr)->setSizePolicy(*static_cast<QSizePolicy*>(sizePolicy));
}

void* QGraphicsWidget_Geometry(void* ptr)
{
		return ({ QRectF tmpValue = static_cast<QGraphicsWidget*>(ptr)->geometry(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsWidget___actions_atList(void* ptr, int i)
{
		return ({QAction * tmp = static_cast<QList<QAction *>*>(ptr)->at(i); if (i == static_cast<QList<QAction *>*>(ptr)->size()-1) { static_cast<QList<QAction *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QGraphicsWidget___actions_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QAction *>();
}

void* QGraphicsWidget___addActions_actions_atList(void* ptr, int i)
{
		return ({QAction * tmp = static_cast<QList<QAction *>*>(ptr)->at(i); if (i == static_cast<QList<QAction *>*>(ptr)->size()-1) { static_cast<QList<QAction *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QGraphicsWidget___addActions_actions_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QAction *>();
}

void* QGraphicsWidget___insertActions_actions_atList(void* ptr, int i)
{
		return ({QAction * tmp = static_cast<QList<QAction *>*>(ptr)->at(i); if (i == static_cast<QList<QAction *>*>(ptr)->size()-1) { static_cast<QList<QAction *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QGraphicsWidget___insertActions_actions_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QAction *>();
}

class MyQGridLayout: public QGridLayout
{
public:
	MyQGridLayout(QWidget *parent) : QGridLayout(parent) {QGridLayout_QGridLayout_QRegisterMetaType();};
	MyQGridLayout() : QGridLayout() {QGridLayout_QGridLayout_QRegisterMetaType();};
	void addItem(QLayoutItem * item) { callbackQGridLayout_AddItem2(this, item); };
	int count() const { return callbackQGridLayout_Count(const_cast<void*>(static_cast<const void*>(this))); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQLayout_ExpandingDirections(const_cast<void*>(static_cast<const void*>(this)))); };
	bool hasHeightForWidth() const { return callbackQLayoutItem_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQLayoutItem_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void invalidate() { callbackQLayoutItem_Invalidate(this); };
	QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQGridLayout_ItemAt(const_cast<void*>(static_cast<const void*>(this)), index)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQLayout_MaximumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	int minimumHeightForWidth(int w) const { return callbackQLayoutItem_MinimumHeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQLayout_MinimumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	void setGeometry(const QRect & rect) { callbackQLayout_SetGeometry(this, const_cast<QRect*>(&rect)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQGridLayout_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQGridLayout_TakeAt(this, index)); };
	 ~MyQGridLayout() { callbackQGridLayout_DestroyQGridLayout(this); };
	void childEvent(QChildEvent * e) { callbackQLayout_ChildEvent(this, e); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayoutItem_ControlTypes(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQLayout_Geometry(const_cast<void*>(static_cast<const void*>(this)))); };
	int indexOf(QWidget * widget) const { return callbackQLayout_IndexOf(const_cast<void*>(static_cast<const void*>(this)), widget); };
	bool isEmpty() const { return callbackQLayout_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QLayout * layout() { return static_cast<QLayout*>(callbackQLayoutItem_Layout(this)); };
	void connectNotify(const QMetaMethod & sign) { callbackQLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQLayout_CustomEvent(this, event); };
	void deleteLater() { callbackQLayout_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQLayout_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQLayout_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQLayout_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLayout_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQLayout_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQLayout_TimerEvent(this, event); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayoutItem_SpacerItem(this)); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQLayoutItem_Widget(this)); };
};

Q_DECLARE_METATYPE(QGridLayout*)
Q_DECLARE_METATYPE(MyQGridLayout*)

int QGridLayout_QGridLayout_QRegisterMetaType(){qRegisterMetaType<QGridLayout*>(); return qRegisterMetaType<MyQGridLayout*>();}

void* QGridLayout_NewQGridLayout(void* parent)
{
		return new MyQGridLayout(static_cast<QWidget*>(parent));
}

void* QGridLayout_NewQGridLayout2()
{
	return new MyQGridLayout();
}

void QGridLayout_AddItem(void* ptr, void* item, int row, int column, int rowSpan, int columnSpan, long long alignment)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
		static_cast<QGridLayout*>(ptr)->addItem(static_cast<QLayout*>(item), row, column, rowSpan, columnSpan, static_cast<Qt::AlignmentFlag>(alignment));
	} else {
		static_cast<QGridLayout*>(ptr)->addItem(static_cast<QLayoutItem*>(item), row, column, rowSpan, columnSpan, static_cast<Qt::AlignmentFlag>(alignment));
	}
}

void QGridLayout_AddItem2(void* ptr, void* item)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
		static_cast<QGridLayout*>(ptr)->addItem(static_cast<QLayout*>(item));
	} else {
		static_cast<QGridLayout*>(ptr)->addItem(static_cast<QLayoutItem*>(item));
	}
}

void QGridLayout_AddItem2Default(void* ptr, void* item)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
		static_cast<QGridLayout*>(ptr)->QGridLayout::addItem(static_cast<QLayout*>(item));
	} else {
		static_cast<QGridLayout*>(ptr)->QGridLayout::addItem(static_cast<QLayoutItem*>(item));
	}
}

void QGridLayout_AddLayout(void* ptr, void* layout, int row, int column, long long alignment)
{
		static_cast<QGridLayout*>(ptr)->addLayout(static_cast<QLayout*>(layout), row, column, static_cast<Qt::AlignmentFlag>(alignment));
}

void QGridLayout_AddLayout2(void* ptr, void* layout, int row, int column, int rowSpan, int columnSpan, long long alignment)
{
		static_cast<QGridLayout*>(ptr)->addLayout(static_cast<QLayout*>(layout), row, column, rowSpan, columnSpan, static_cast<Qt::AlignmentFlag>(alignment));
}

void QGridLayout_AddWidget2(void* ptr, void* widget, int row, int column, long long alignment)
{
		static_cast<QGridLayout*>(ptr)->addWidget(static_cast<QWidget*>(widget), row, column, static_cast<Qt::AlignmentFlag>(alignment));
}

void QGridLayout_AddWidget3(void* ptr, void* widget, int fromRow, int fromColumn, int rowSpan, int columnSpan, long long alignment)
{
		static_cast<QGridLayout*>(ptr)->addWidget(static_cast<QWidget*>(widget), fromRow, fromColumn, rowSpan, columnSpan, static_cast<Qt::AlignmentFlag>(alignment));
}

void* QGridLayout_CellRect(void* ptr, int row, int column)
{
	return ({ QRect tmpValue = static_cast<QGridLayout*>(ptr)->cellRect(row, column); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

int QGridLayout_ColumnCount(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->columnCount();
}

int QGridLayout_ColumnMinimumWidth(void* ptr, int column)
{
	return static_cast<QGridLayout*>(ptr)->columnMinimumWidth(column);
}

int QGridLayout_ColumnStretch(void* ptr, int column)
{
	return static_cast<QGridLayout*>(ptr)->columnStretch(column);
}

int QGridLayout_Count(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->count();
}

int QGridLayout_CountDefault(void* ptr)
{
		return static_cast<QGridLayout*>(ptr)->QGridLayout::count();
}

void QGridLayout_GetItemPosition(void* ptr, int index, int row, int column, int rowSpan, int columnSpan)
{
	static_cast<QGridLayout*>(ptr)->getItemPosition(index, &row, &column, &rowSpan, &columnSpan);
}

int QGridLayout_HorizontalSpacing(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->horizontalSpacing();
}

void* QGridLayout_ItemAt(void* ptr, int index)
{
	return static_cast<QGridLayout*>(ptr)->itemAt(index);
}

void* QGridLayout_ItemAtDefault(void* ptr, int index)
{
		return static_cast<QGridLayout*>(ptr)->QGridLayout::itemAt(index);
}

void* QGridLayout_ItemAtPosition(void* ptr, int row, int column)
{
	return static_cast<QGridLayout*>(ptr)->itemAtPosition(row, column);
}

long long QGridLayout_OriginCorner(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->originCorner();
}

int QGridLayout_RowCount(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->rowCount();
}

int QGridLayout_RowMinimumHeight(void* ptr, int row)
{
	return static_cast<QGridLayout*>(ptr)->rowMinimumHeight(row);
}

int QGridLayout_RowStretch(void* ptr, int row)
{
	return static_cast<QGridLayout*>(ptr)->rowStretch(row);
}

void QGridLayout_SetColumnMinimumWidth(void* ptr, int column, int minSize)
{
	static_cast<QGridLayout*>(ptr)->setColumnMinimumWidth(column, minSize);
}

void QGridLayout_SetColumnStretch(void* ptr, int column, int stretch)
{
	static_cast<QGridLayout*>(ptr)->setColumnStretch(column, stretch);
}

void QGridLayout_SetHorizontalSpacing(void* ptr, int spacing)
{
	static_cast<QGridLayout*>(ptr)->setHorizontalSpacing(spacing);
}

void QGridLayout_SetOriginCorner(void* ptr, long long corner)
{
	static_cast<QGridLayout*>(ptr)->setOriginCorner(static_cast<Qt::Corner>(corner));
}

void QGridLayout_SetRowMinimumHeight(void* ptr, int row, int minSize)
{
	static_cast<QGridLayout*>(ptr)->setRowMinimumHeight(row, minSize);
}

void QGridLayout_SetRowStretch(void* ptr, int row, int stretch)
{
	static_cast<QGridLayout*>(ptr)->setRowStretch(row, stretch);
}

void QGridLayout_SetVerticalSpacing(void* ptr, int spacing)
{
	static_cast<QGridLayout*>(ptr)->setVerticalSpacing(spacing);
}

void* QGridLayout_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QGridLayout*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QGridLayout_SizeHintDefault(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QGridLayout*>(ptr)->QGridLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QGridLayout_TakeAt(void* ptr, int index)
{
	return static_cast<QGridLayout*>(ptr)->takeAt(index);
}

void* QGridLayout_TakeAtDefault(void* ptr, int index)
{
		return static_cast<QGridLayout*>(ptr)->QGridLayout::takeAt(index);
}

int QGridLayout_VerticalSpacing(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->verticalSpacing();
}

void QGridLayout_DestroyQGridLayout(void* ptr)
{
	static_cast<QGridLayout*>(ptr)->~QGridLayout();
}

void QGridLayout_DestroyQGridLayoutDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQGroupBox: public QGroupBox
{
public:
	MyQGroupBox(QWidget *parent = Q_NULLPTR) : QGroupBox(parent) {QGroupBox_QGroupBox_QRegisterMetaType();};
	MyQGroupBox(const QString &title, QWidget *parent = Q_NULLPTR) : QGroupBox(title, parent) {QGroupBox_QGroupBox_QRegisterMetaType();};
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void childEvent(QChildEvent * c) { callbackQWidget_ChildEvent(this, c); };
	void Signal_Clicked(bool checked) { callbackQGroupBox_Clicked(this, checked); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void focusInEvent(QFocusEvent * fe) { callbackQWidget_FocusInEvent(this, fe); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void setChecked(bool checked) { callbackQGroupBox_SetChecked(this, checked); };
	void Signal_Toggled(bool on) { callbackQGroupBox_Toggled(this, on); };
	 ~MyQGroupBox() { callbackQGroupBox_DestroyQGroupBox(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QGroupBox*)
Q_DECLARE_METATYPE(MyQGroupBox*)

int QGroupBox_QGroupBox_QRegisterMetaType(){qRegisterMetaType<QGroupBox*>(); return qRegisterMetaType<MyQGroupBox*>();}

void* QGroupBox_NewQGroupBox(void* parent)
{
		return new MyQGroupBox(static_cast<QWidget*>(parent));
}

void* QGroupBox_NewQGroupBox2(struct QtWidgets_PackedString title, void* parent)
{
		return new MyQGroupBox(QString::fromUtf8(title.data, title.len), static_cast<QWidget*>(parent));
}

long long QGroupBox_Alignment(void* ptr)
{
	return static_cast<QGroupBox*>(ptr)->alignment();
}

void QGroupBox_ConnectClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QGroupBox*>(ptr), static_cast<void (QGroupBox::*)(bool)>(&QGroupBox::clicked), static_cast<MyQGroupBox*>(ptr), static_cast<void (MyQGroupBox::*)(bool)>(&MyQGroupBox::Signal_Clicked), static_cast<Qt::ConnectionType>(t));
}

void QGroupBox_DisconnectClicked(void* ptr)
{
	QObject::disconnect(static_cast<QGroupBox*>(ptr), static_cast<void (QGroupBox::*)(bool)>(&QGroupBox::clicked), static_cast<MyQGroupBox*>(ptr), static_cast<void (MyQGroupBox::*)(bool)>(&MyQGroupBox::Signal_Clicked));
}

void QGroupBox_Clicked(void* ptr, char checked)
{
	static_cast<QGroupBox*>(ptr)->clicked(checked != 0);
}

void QGroupBox_InitStyleOption(void* ptr, void* option)
{
	static_cast<QGroupBox*>(ptr)->initStyleOption(static_cast<QStyleOptionGroupBox*>(option));
}

char QGroupBox_IsCheckable(void* ptr)
{
	return static_cast<QGroupBox*>(ptr)->isCheckable();
}

char QGroupBox_IsChecked(void* ptr)
{
	return static_cast<QGroupBox*>(ptr)->isChecked();
}

char QGroupBox_IsFlat(void* ptr)
{
	return static_cast<QGroupBox*>(ptr)->isFlat();
}

void QGroupBox_SetAlignment(void* ptr, int alignment)
{
	static_cast<QGroupBox*>(ptr)->setAlignment(alignment);
}

void QGroupBox_SetCheckable(void* ptr, char checkable)
{
	static_cast<QGroupBox*>(ptr)->setCheckable(checkable != 0);
}

void QGroupBox_SetChecked(void* ptr, char checked)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setChecked", Q_ARG(bool, checked != 0));
}

void QGroupBox_SetCheckedDefault(void* ptr, char checked)
{
		static_cast<QGroupBox*>(ptr)->QGroupBox::setChecked(checked != 0);
}

void QGroupBox_SetFlat(void* ptr, char flat)
{
	static_cast<QGroupBox*>(ptr)->setFlat(flat != 0);
}

void QGroupBox_SetTitle(void* ptr, struct QtWidgets_PackedString title)
{
	static_cast<QGroupBox*>(ptr)->setTitle(QString::fromUtf8(title.data, title.len));
}

struct QtWidgets_PackedString QGroupBox_Title(void* ptr)
{
	return ({ QByteArray* t937a1b = new QByteArray(static_cast<QGroupBox*>(ptr)->title().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t937a1b->prepend("WHITESPACE").constData()+10), t937a1b->size()-10, t937a1b }; });
}

void QGroupBox_ConnectToggled(void* ptr, long long t)
{
	QObject::connect(static_cast<QGroupBox*>(ptr), static_cast<void (QGroupBox::*)(bool)>(&QGroupBox::toggled), static_cast<MyQGroupBox*>(ptr), static_cast<void (MyQGroupBox::*)(bool)>(&MyQGroupBox::Signal_Toggled), static_cast<Qt::ConnectionType>(t));
}

void QGroupBox_DisconnectToggled(void* ptr)
{
	QObject::disconnect(static_cast<QGroupBox*>(ptr), static_cast<void (QGroupBox::*)(bool)>(&QGroupBox::toggled), static_cast<MyQGroupBox*>(ptr), static_cast<void (MyQGroupBox::*)(bool)>(&MyQGroupBox::Signal_Toggled));
}

void QGroupBox_Toggled(void* ptr, char on)
{
	static_cast<QGroupBox*>(ptr)->toggled(on != 0);
}

void QGroupBox_DestroyQGroupBox(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->~QGroupBox();
}

void QGroupBox_DestroyQGroupBoxDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQHBoxLayout: public QHBoxLayout
{
public:
	MyQHBoxLayout() : QHBoxLayout() {QHBoxLayout_QHBoxLayout_QRegisterMetaType();};
	MyQHBoxLayout(QWidget *parent) : QHBoxLayout(parent) {QHBoxLayout_QHBoxLayout_QRegisterMetaType();};
	 ~MyQHBoxLayout() { callbackQHBoxLayout_DestroyQHBoxLayout(this); };
	void addItem(QLayoutItem * item) { callbackQBoxLayout_AddItem(this, item); };
	int count() const { return callbackQBoxLayout_Count(const_cast<void*>(static_cast<const void*>(this))); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQLayout_ExpandingDirections(const_cast<void*>(static_cast<const void*>(this)))); };
	bool hasHeightForWidth() const { return callbackQLayoutItem_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQLayoutItem_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void invalidate() { callbackQLayoutItem_Invalidate(this); };
	QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQBoxLayout_ItemAt(const_cast<void*>(static_cast<const void*>(this)), index)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQLayout_MaximumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	int minimumHeightForWidth(int w) const { return callbackQLayoutItem_MinimumHeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQLayout_MinimumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	void setGeometry(const QRect & r) { callbackQLayout_SetGeometry(this, const_cast<QRect*>(&r)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQBoxLayout_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQBoxLayout_TakeAt(this, index)); };
	void childEvent(QChildEvent * e) { callbackQLayout_ChildEvent(this, e); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayoutItem_ControlTypes(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQLayout_Geometry(const_cast<void*>(static_cast<const void*>(this)))); };
	int indexOf(QWidget * widget) const { return callbackQLayout_IndexOf(const_cast<void*>(static_cast<const void*>(this)), widget); };
	bool isEmpty() const { return callbackQLayout_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QLayout * layout() { return static_cast<QLayout*>(callbackQLayoutItem_Layout(this)); };
	void connectNotify(const QMetaMethod & sign) { callbackQLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQLayout_CustomEvent(this, event); };
	void deleteLater() { callbackQLayout_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQLayout_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQLayout_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQLayout_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLayout_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQLayout_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQLayout_TimerEvent(this, event); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayoutItem_SpacerItem(this)); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQLayoutItem_Widget(this)); };
};

Q_DECLARE_METATYPE(QHBoxLayout*)
Q_DECLARE_METATYPE(MyQHBoxLayout*)

int QHBoxLayout_QHBoxLayout_QRegisterMetaType(){qRegisterMetaType<QHBoxLayout*>(); return qRegisterMetaType<MyQHBoxLayout*>();}

void* QHBoxLayout_NewQHBoxLayout()
{
	return new MyQHBoxLayout();
}

void* QHBoxLayout_NewQHBoxLayout2(void* parent)
{
		return new MyQHBoxLayout(static_cast<QWidget*>(parent));
}

void QHBoxLayout_DestroyQHBoxLayout(void* ptr)
{
	static_cast<QHBoxLayout*>(ptr)->~QHBoxLayout();
}

void QHBoxLayout_DestroyQHBoxLayoutDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQHeaderView: public QHeaderView
{
public:
	MyQHeaderView(Qt::Orientation orientation, QWidget *parent = Q_NULLPTR) : QHeaderView(orientation, parent) {QHeaderView_QHeaderView_QRegisterMetaType();};
	void currentChanged(const QModelIndex & current, const QModelIndex & old) { callbackQHeaderView_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&old)); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void Signal_GeometriesChanged() { callbackQHeaderView_GeometriesChanged(this); };
	void headerDataChanged(Qt::Orientation orientation, int logicalFirst, int logicalLast) { callbackQHeaderView_HeaderDataChanged(this, orientation, logicalFirst, logicalLast); };
	int horizontalOffset() const { return callbackQHeaderView_HorizontalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQWidget_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQWidget_PaintEvent(this, e); };
	void paintSection(QPainter * painter, const QRect & rect, int logicalIndex) const { callbackQHeaderView_PaintSection(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QRect*>(&rect), logicalIndex); };
	void reset() { callbackQHeaderView_Reset(this); };
	void resizeSections() { callbackQHeaderView_ResizeSections2(this); };
	void Signal_SectionClicked(int logicalIndex) { callbackQHeaderView_SectionClicked(this, logicalIndex); };
	void Signal_SectionCountChanged(int oldCount, int newCount) { callbackQHeaderView_SectionCountChanged(this, oldCount, newCount); };
	void Signal_SectionDoubleClicked(int logicalIndex) { callbackQHeaderView_SectionDoubleClicked(this, logicalIndex); };
	void Signal_SectionEntered(int logicalIndex) { callbackQHeaderView_SectionEntered(this, logicalIndex); };
	void Signal_SectionHandleDoubleClicked(int logicalIndex) { callbackQHeaderView_SectionHandleDoubleClicked(this, logicalIndex); };
	void Signal_SectionMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex) { callbackQHeaderView_SectionMoved(this, logicalIndex, oldVisualIndex, newVisualIndex); };
	void Signal_SectionPressed(int logicalIndex) { callbackQHeaderView_SectionPressed(this, logicalIndex); };
	void Signal_SectionResized(int logicalIndex, int oldSize, int newSize) { callbackQHeaderView_SectionResized(this, logicalIndex, oldSize, newSize); };
	QSize sectionSizeFromContents(int logicalIndex) const { return *static_cast<QSize*>(callbackQHeaderView_SectionSizeFromContents(const_cast<void*>(static_cast<const void*>(this)), logicalIndex)); };
	void sectionsAboutToBeRemoved(const QModelIndex & parent, int logicalFirst, int logicalLast) { callbackQHeaderView_SectionsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), logicalFirst, logicalLast); };
	void sectionsInserted(const QModelIndex & parent, int logicalFirst, int logicalLast) { callbackQHeaderView_SectionsInserted(this, const_cast<QModelIndex*>(&parent), logicalFirst, logicalLast); };
	void setModel(QAbstractItemModel * model) { callbackQAbstractItemView_SetModel(this, model); };
	void setOffset(int offset) { callbackQHeaderView_SetOffset(this, offset); };
	void setOffsetToLastSection() { callbackQHeaderView_SetOffsetToLastSection(this); };
	void setOffsetToSectionPosition(int visualSectionNumber) { callbackQHeaderView_SetOffsetToSectionPosition(this, visualSectionNumber); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags flags) { callbackQHeaderView_SetSelection(this, const_cast<QRect*>(&rect), flags); };
	void setVisible(bool v) { callbackQHeaderView_SetVisible(this, v); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_SortIndicatorChanged(int logicalIndex, Qt::SortOrder order) { callbackQHeaderView_SortIndicatorChanged(this, logicalIndex, order); };
	int verticalOffset() const { return callbackQHeaderView_VerticalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	bool viewportEvent(QEvent * e) { return callbackQAbstractScrollArea_ViewportEvent(this, e) != 0; };
	 ~MyQHeaderView() { callbackQHeaderView_DestroyQHeaderView(this); };
	void Signal_Activated(const QModelIndex & index) { callbackQAbstractItemView_Activated(this, const_cast<QModelIndex*>(&index)); };
	void clearSelection() { callbackQAbstractItemView_ClearSelection(this); };
	void Signal_Clicked(const QModelIndex & index) { callbackQAbstractItemView_Clicked(this, const_cast<QModelIndex*>(&index)); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQAbstractItemView_CommitData(this, editor); };
	void dataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemView_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
	void Signal_DoubleClicked(const QModelIndex & index) { callbackQAbstractItemView_DoubleClicked(this, const_cast<QModelIndex*>(&index)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQAbstractItemView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQAbstractItemView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQAbstractItemView_EditorDestroyed(this, editor); };
	void Signal_Entered(const QModelIndex & index) { callbackQAbstractItemView_Entered(this, const_cast<QModelIndex*>(&index)); };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQWidget_EventFilter(this, object, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void Signal_IconSizeChanged(const QSize & size) { callbackQAbstractItemView_IconSizeChanged(this, const_cast<QSize*>(&size)); };
	QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQHeaderView_IndexAt(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&point))); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQHeaderView_IsIndexHidden(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index)) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { QByteArray* t3559d7 = new QByteArray(search.toUtf8()); QtWidgets_PackedString searchPacked = { const_cast<char*>(t3559d7->prepend("WHITESPACE").constData()+10), t3559d7->size()-10, t3559d7 };callbackQAbstractItemView_KeyboardSearch(this, searchPacked); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQHeaderView_MoveCursor(this, cursorAction, modifiers)); };
	void Signal_Pressed(const QModelIndex & index) { callbackQAbstractItemView_Pressed(this, const_cast<QModelIndex*>(&index)); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQAbstractItemView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemView_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQHeaderView_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	void scrollToBottom() { callbackQAbstractItemView_ScrollToBottom(this); };
	void scrollToTop() { callbackQAbstractItemView_ScrollToTop(this); };
	void selectAll() { callbackQAbstractItemView_SelectAll(this); };
	QList<QModelIndex> selectedIndexes() const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemView_SelectedIndexes(const_cast<void*>(static_cast<const void*>(this)))); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQAbstractItemView_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQAbstractItemView_SelectionCommand(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQAbstractItemView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	void setRootIndex(const QModelIndex & index) { callbackQAbstractItemView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQAbstractItemView_SetSelectionModel(this, selectionModel); };
	int sizeHintForColumn(int column) const { return callbackQAbstractItemView_SizeHintForColumn(const_cast<void*>(static_cast<const void*>(this)), column); };
	int sizeHintForRow(int row) const { return callbackQAbstractItemView_SizeHintForRow(const_cast<void*>(static_cast<const void*>(this)), row); };
	void startDrag(Qt::DropActions supportedActions) { callbackQAbstractItemView_StartDrag(this, supportedActions); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	void update(const QModelIndex & index) { callbackQAbstractItemView_Update(this, const_cast<QModelIndex*>(&index)); };
	void updateGeometries() { callbackQAbstractItemView_UpdateGeometries(this); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQAbstractItemView_ViewOptions(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ViewportEntered() { callbackQAbstractItemView_ViewportEntered(this); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQHeaderView_VisualRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQHeaderView_VisualRegionForSelection(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&selection))); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QHeaderView*)
Q_DECLARE_METATYPE(MyQHeaderView*)

int QHeaderView_QHeaderView_QRegisterMetaType(){qRegisterMetaType<QHeaderView*>(); return qRegisterMetaType<MyQHeaderView*>();}

void* QHeaderView_NewQHeaderView(long long orientation, void* parent)
{
		return new MyQHeaderView(static_cast<Qt::Orientation>(orientation), static_cast<QWidget*>(parent));
}

char QHeaderView_CascadingSectionResizes(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->cascadingSectionResizes();
}

int QHeaderView_Count(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->count();
}

void QHeaderView_CurrentChanged(void* ptr, void* current, void* old)
{
	static_cast<QHeaderView*>(ptr)->currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(old));
}

void QHeaderView_CurrentChangedDefault(void* ptr, void* current, void* old)
{
		static_cast<QHeaderView*>(ptr)->QHeaderView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(old));
}

long long QHeaderView_DefaultAlignment(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->defaultAlignment();
}

int QHeaderView_DefaultSectionSize(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->defaultSectionSize();
}

void QHeaderView_ConnectGeometriesChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)()>(&QHeaderView::geometriesChanged), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)()>(&MyQHeaderView::Signal_GeometriesChanged), static_cast<Qt::ConnectionType>(t));
}

void QHeaderView_DisconnectGeometriesChanged(void* ptr)
{
	QObject::disconnect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)()>(&QHeaderView::geometriesChanged), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)()>(&MyQHeaderView::Signal_GeometriesChanged));
}

void QHeaderView_GeometriesChanged(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->geometriesChanged();
}

void QHeaderView_HeaderDataChanged(void* ptr, long long orientation, int logicalFirst, int logicalLast)
{
	qRegisterMetaType<Qt::Orientation>();
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "headerDataChanged", Q_ARG(Qt::Orientation, static_cast<Qt::Orientation>(orientation)), Q_ARG(int, logicalFirst), Q_ARG(int, logicalLast));
}

void QHeaderView_HeaderDataChangedDefault(void* ptr, long long orientation, int logicalFirst, int logicalLast)
{
		static_cast<QHeaderView*>(ptr)->QHeaderView::headerDataChanged(static_cast<Qt::Orientation>(orientation), logicalFirst, logicalLast);
}

int QHeaderView_HiddenSectionCount(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->hiddenSectionCount();
}

void QHeaderView_HideSection(void* ptr, int logicalIndex)
{
	static_cast<QHeaderView*>(ptr)->hideSection(logicalIndex);
}

char QHeaderView_HighlightSections(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->highlightSections();
}

int QHeaderView_HorizontalOffset(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->horizontalOffset();
}

int QHeaderView_HorizontalOffsetDefault(void* ptr)
{
		return static_cast<QHeaderView*>(ptr)->QHeaderView::horizontalOffset();
}

void QHeaderView_InitStyleOption(void* ptr, void* option)
{
	static_cast<QHeaderView*>(ptr)->initStyleOption(static_cast<QStyleOptionHeader*>(option));
}

char QHeaderView_IsFirstSectionMovable(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->isFirstSectionMovable();
}

char QHeaderView_IsSectionHidden(void* ptr, int logicalIndex)
{
	return static_cast<QHeaderView*>(ptr)->isSectionHidden(logicalIndex);
}

char QHeaderView_IsSortIndicatorShown(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->isSortIndicatorShown();
}

int QHeaderView_Length(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->length();
}

int QHeaderView_LogicalIndex(void* ptr, int visualIndex)
{
	return static_cast<QHeaderView*>(ptr)->logicalIndex(visualIndex);
}

int QHeaderView_LogicalIndexAt(void* ptr, int position)
{
	return static_cast<QHeaderView*>(ptr)->logicalIndexAt(position);
}

int QHeaderView_LogicalIndexAt2(void* ptr, int x, int y)
{
	return static_cast<QHeaderView*>(ptr)->logicalIndexAt(x, y);
}

int QHeaderView_LogicalIndexAt3(void* ptr, void* pos)
{
	return static_cast<QHeaderView*>(ptr)->logicalIndexAt(*static_cast<QPoint*>(pos));
}

int QHeaderView_MaximumSectionSize(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->maximumSectionSize();
}

int QHeaderView_MinimumSectionSize(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->minimumSectionSize();
}

void QHeaderView_MoveSection(void* ptr, int from, int to)
{
	static_cast<QHeaderView*>(ptr)->moveSection(from, to);
}

int QHeaderView_Offset(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->offset();
}

long long QHeaderView_Orientation(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->orientation();
}

void QHeaderView_PaintSection(void* ptr, void* painter, void* rect, int logicalIndex)
{
	static_cast<QHeaderView*>(ptr)->paintSection(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), logicalIndex);
}

void QHeaderView_PaintSectionDefault(void* ptr, void* painter, void* rect, int logicalIndex)
{
		static_cast<QHeaderView*>(ptr)->QHeaderView::paintSection(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), logicalIndex);
}

void QHeaderView_Reset(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->reset();
}

void QHeaderView_ResetDefault(void* ptr)
{
		static_cast<QHeaderView*>(ptr)->QHeaderView::reset();
}

void QHeaderView_ResetDefaultSectionSize(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->resetDefaultSectionSize();
}

int QHeaderView_ResizeContentsPrecision(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->resizeContentsPrecision();
}

void QHeaderView_ResizeSection(void* ptr, int logicalIndex, int size)
{
	static_cast<QHeaderView*>(ptr)->resizeSection(logicalIndex, size);
}

void QHeaderView_ResizeSections(void* ptr, long long mode)
{
	static_cast<QHeaderView*>(ptr)->resizeSections(static_cast<QHeaderView::ResizeMode>(mode));
}

void QHeaderView_ResizeSections2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "resizeSections");
}

void QHeaderView_ResizeSections2Default(void* ptr)
{
		static_cast<QHeaderView*>(ptr)->QHeaderView::resizeSections();
}

char QHeaderView_RestoreState(void* ptr, void* state)
{
	return static_cast<QHeaderView*>(ptr)->restoreState(*static_cast<QByteArray*>(state));
}

void* QHeaderView_SaveState(void* ptr)
{
	return new QByteArray(static_cast<QHeaderView*>(ptr)->saveState());
}

void QHeaderView_ConnectSectionClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int)>(&QHeaderView::sectionClicked), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int)>(&MyQHeaderView::Signal_SectionClicked), static_cast<Qt::ConnectionType>(t));
}

void QHeaderView_DisconnectSectionClicked(void* ptr)
{
	QObject::disconnect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int)>(&QHeaderView::sectionClicked), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int)>(&MyQHeaderView::Signal_SectionClicked));
}

void QHeaderView_SectionClicked(void* ptr, int logicalIndex)
{
	static_cast<QHeaderView*>(ptr)->sectionClicked(logicalIndex);
}

void QHeaderView_ConnectSectionCountChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int, int)>(&QHeaderView::sectionCountChanged), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int, int)>(&MyQHeaderView::Signal_SectionCountChanged), static_cast<Qt::ConnectionType>(t));
}

void QHeaderView_DisconnectSectionCountChanged(void* ptr)
{
	QObject::disconnect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int, int)>(&QHeaderView::sectionCountChanged), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int, int)>(&MyQHeaderView::Signal_SectionCountChanged));
}

void QHeaderView_SectionCountChanged(void* ptr, int oldCount, int newCount)
{
	static_cast<QHeaderView*>(ptr)->sectionCountChanged(oldCount, newCount);
}

void QHeaderView_ConnectSectionDoubleClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int)>(&QHeaderView::sectionDoubleClicked), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int)>(&MyQHeaderView::Signal_SectionDoubleClicked), static_cast<Qt::ConnectionType>(t));
}

void QHeaderView_DisconnectSectionDoubleClicked(void* ptr)
{
	QObject::disconnect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int)>(&QHeaderView::sectionDoubleClicked), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int)>(&MyQHeaderView::Signal_SectionDoubleClicked));
}

void QHeaderView_SectionDoubleClicked(void* ptr, int logicalIndex)
{
	static_cast<QHeaderView*>(ptr)->sectionDoubleClicked(logicalIndex);
}

void QHeaderView_ConnectSectionEntered(void* ptr, long long t)
{
	QObject::connect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int)>(&QHeaderView::sectionEntered), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int)>(&MyQHeaderView::Signal_SectionEntered), static_cast<Qt::ConnectionType>(t));
}

void QHeaderView_DisconnectSectionEntered(void* ptr)
{
	QObject::disconnect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int)>(&QHeaderView::sectionEntered), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int)>(&MyQHeaderView::Signal_SectionEntered));
}

void QHeaderView_SectionEntered(void* ptr, int logicalIndex)
{
	static_cast<QHeaderView*>(ptr)->sectionEntered(logicalIndex);
}

void QHeaderView_ConnectSectionHandleDoubleClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int)>(&QHeaderView::sectionHandleDoubleClicked), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int)>(&MyQHeaderView::Signal_SectionHandleDoubleClicked), static_cast<Qt::ConnectionType>(t));
}

void QHeaderView_DisconnectSectionHandleDoubleClicked(void* ptr)
{
	QObject::disconnect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int)>(&QHeaderView::sectionHandleDoubleClicked), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int)>(&MyQHeaderView::Signal_SectionHandleDoubleClicked));
}

void QHeaderView_SectionHandleDoubleClicked(void* ptr, int logicalIndex)
{
	static_cast<QHeaderView*>(ptr)->sectionHandleDoubleClicked(logicalIndex);
}

void QHeaderView_ConnectSectionMoved(void* ptr, long long t)
{
	QObject::connect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int, int, int)>(&QHeaderView::sectionMoved), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int, int, int)>(&MyQHeaderView::Signal_SectionMoved), static_cast<Qt::ConnectionType>(t));
}

void QHeaderView_DisconnectSectionMoved(void* ptr)
{
	QObject::disconnect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int, int, int)>(&QHeaderView::sectionMoved), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int, int, int)>(&MyQHeaderView::Signal_SectionMoved));
}

void QHeaderView_SectionMoved(void* ptr, int logicalIndex, int oldVisualIndex, int newVisualIndex)
{
	static_cast<QHeaderView*>(ptr)->sectionMoved(logicalIndex, oldVisualIndex, newVisualIndex);
}

int QHeaderView_SectionPosition(void* ptr, int logicalIndex)
{
	return static_cast<QHeaderView*>(ptr)->sectionPosition(logicalIndex);
}

void QHeaderView_ConnectSectionPressed(void* ptr, long long t)
{
	QObject::connect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int)>(&QHeaderView::sectionPressed), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int)>(&MyQHeaderView::Signal_SectionPressed), static_cast<Qt::ConnectionType>(t));
}

void QHeaderView_DisconnectSectionPressed(void* ptr)
{
	QObject::disconnect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int)>(&QHeaderView::sectionPressed), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int)>(&MyQHeaderView::Signal_SectionPressed));
}

void QHeaderView_SectionPressed(void* ptr, int logicalIndex)
{
	static_cast<QHeaderView*>(ptr)->sectionPressed(logicalIndex);
}

long long QHeaderView_SectionResizeMode(void* ptr, int logicalIndex)
{
	return static_cast<QHeaderView*>(ptr)->sectionResizeMode(logicalIndex);
}

void QHeaderView_ConnectSectionResized(void* ptr, long long t)
{
	QObject::connect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int, int, int)>(&QHeaderView::sectionResized), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int, int, int)>(&MyQHeaderView::Signal_SectionResized), static_cast<Qt::ConnectionType>(t));
}

void QHeaderView_DisconnectSectionResized(void* ptr)
{
	QObject::disconnect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int, int, int)>(&QHeaderView::sectionResized), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int, int, int)>(&MyQHeaderView::Signal_SectionResized));
}

void QHeaderView_SectionResized(void* ptr, int logicalIndex, int oldSize, int newSize)
{
	static_cast<QHeaderView*>(ptr)->sectionResized(logicalIndex, oldSize, newSize);
}

int QHeaderView_SectionSize(void* ptr, int logicalIndex)
{
	return static_cast<QHeaderView*>(ptr)->sectionSize(logicalIndex);
}

void* QHeaderView_SectionSizeFromContents(void* ptr, int logicalIndex)
{
	return ({ QSize tmpValue = static_cast<QHeaderView*>(ptr)->sectionSizeFromContents(logicalIndex); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QHeaderView_SectionSizeFromContentsDefault(void* ptr, int logicalIndex)
{
		return ({ QSize tmpValue = static_cast<QHeaderView*>(ptr)->QHeaderView::sectionSizeFromContents(logicalIndex); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QHeaderView_SectionSizeHint(void* ptr, int logicalIndex)
{
	return static_cast<QHeaderView*>(ptr)->sectionSizeHint(logicalIndex);
}

int QHeaderView_SectionViewportPosition(void* ptr, int logicalIndex)
{
	return static_cast<QHeaderView*>(ptr)->sectionViewportPosition(logicalIndex);
}

void QHeaderView_SectionsAboutToBeRemoved(void* ptr, void* parent, int logicalFirst, int logicalLast)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "sectionsAboutToBeRemoved", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, logicalFirst), Q_ARG(int, logicalLast));
}

void QHeaderView_SectionsAboutToBeRemovedDefault(void* ptr, void* parent, int logicalFirst, int logicalLast)
{
		static_cast<QHeaderView*>(ptr)->QHeaderView::sectionsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), logicalFirst, logicalLast);
}

char QHeaderView_SectionsClickable(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->sectionsClickable();
}

char QHeaderView_SectionsHidden(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->sectionsHidden();
}

void QHeaderView_SectionsInserted(void* ptr, void* parent, int logicalFirst, int logicalLast)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "sectionsInserted", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, logicalFirst), Q_ARG(int, logicalLast));
}

void QHeaderView_SectionsInsertedDefault(void* ptr, void* parent, int logicalFirst, int logicalLast)
{
		static_cast<QHeaderView*>(ptr)->QHeaderView::sectionsInserted(*static_cast<QModelIndex*>(parent), logicalFirst, logicalLast);
}

char QHeaderView_SectionsMovable(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->sectionsMovable();
}

char QHeaderView_SectionsMoved(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->sectionsMoved();
}

void QHeaderView_SetCascadingSectionResizes(void* ptr, char enable)
{
	static_cast<QHeaderView*>(ptr)->setCascadingSectionResizes(enable != 0);
}

void QHeaderView_SetDefaultAlignment(void* ptr, long long alignment)
{
	static_cast<QHeaderView*>(ptr)->setDefaultAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}

void QHeaderView_SetDefaultSectionSize(void* ptr, int size)
{
	static_cast<QHeaderView*>(ptr)->setDefaultSectionSize(size);
}

void QHeaderView_SetFirstSectionMovable(void* ptr, char movable)
{
	static_cast<QHeaderView*>(ptr)->setFirstSectionMovable(movable != 0);
}

void QHeaderView_SetHighlightSections(void* ptr, char highlight)
{
	static_cast<QHeaderView*>(ptr)->setHighlightSections(highlight != 0);
}

void QHeaderView_SetMaximumSectionSize(void* ptr, int size)
{
	static_cast<QHeaderView*>(ptr)->setMaximumSectionSize(size);
}

void QHeaderView_SetMinimumSectionSize(void* ptr, int size)
{
	static_cast<QHeaderView*>(ptr)->setMinimumSectionSize(size);
}

void QHeaderView_SetOffset(void* ptr, int offset)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setOffset", Q_ARG(int, offset));
}

void QHeaderView_SetOffsetDefault(void* ptr, int offset)
{
		static_cast<QHeaderView*>(ptr)->QHeaderView::setOffset(offset);
}

void QHeaderView_SetOffsetToLastSection(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setOffsetToLastSection");
}

void QHeaderView_SetOffsetToLastSectionDefault(void* ptr)
{
		static_cast<QHeaderView*>(ptr)->QHeaderView::setOffsetToLastSection();
}

void QHeaderView_SetOffsetToSectionPosition(void* ptr, int visualSectionNumber)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setOffsetToSectionPosition", Q_ARG(int, visualSectionNumber));
}

void QHeaderView_SetOffsetToSectionPositionDefault(void* ptr, int visualSectionNumber)
{
		static_cast<QHeaderView*>(ptr)->QHeaderView::setOffsetToSectionPosition(visualSectionNumber);
}

void QHeaderView_SetResizeContentsPrecision(void* ptr, int precision)
{
	static_cast<QHeaderView*>(ptr)->setResizeContentsPrecision(precision);
}

void QHeaderView_SetSectionHidden(void* ptr, int logicalIndex, char hide)
{
	static_cast<QHeaderView*>(ptr)->setSectionHidden(logicalIndex, hide != 0);
}

void QHeaderView_SetSectionResizeMode(void* ptr, long long mode)
{
	static_cast<QHeaderView*>(ptr)->setSectionResizeMode(static_cast<QHeaderView::ResizeMode>(mode));
}

void QHeaderView_SetSectionResizeMode2(void* ptr, int logicalIndex, long long mode)
{
	static_cast<QHeaderView*>(ptr)->setSectionResizeMode(logicalIndex, static_cast<QHeaderView::ResizeMode>(mode));
}

void QHeaderView_SetSectionsClickable(void* ptr, char clickable)
{
	static_cast<QHeaderView*>(ptr)->setSectionsClickable(clickable != 0);
}

void QHeaderView_SetSectionsMovable(void* ptr, char movable)
{
	static_cast<QHeaderView*>(ptr)->setSectionsMovable(movable != 0);
}

void QHeaderView_SetSelection(void* ptr, void* rect, long long flags)
{
	static_cast<QHeaderView*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
}

void QHeaderView_SetSelectionDefault(void* ptr, void* rect, long long flags)
{
		static_cast<QHeaderView*>(ptr)->QHeaderView::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
}

void QHeaderView_SetSortIndicator(void* ptr, int logicalIndex, long long order)
{
	static_cast<QHeaderView*>(ptr)->setSortIndicator(logicalIndex, static_cast<Qt::SortOrder>(order));
}

void QHeaderView_SetSortIndicatorShown(void* ptr, char show)
{
	static_cast<QHeaderView*>(ptr)->setSortIndicatorShown(show != 0);
}

void QHeaderView_SetStretchLastSection(void* ptr, char stretch)
{
	static_cast<QHeaderView*>(ptr)->setStretchLastSection(stretch != 0);
}

void QHeaderView_SetVisible(void* ptr, char v)
{
	static_cast<QHeaderView*>(ptr)->setVisible(v != 0);
}

void QHeaderView_SetVisibleDefault(void* ptr, char v)
{
		static_cast<QHeaderView*>(ptr)->QHeaderView::setVisible(v != 0);
}

void QHeaderView_ShowSection(void* ptr, int logicalIndex)
{
	static_cast<QHeaderView*>(ptr)->showSection(logicalIndex);
}

void QHeaderView_ConnectSortIndicatorChanged(void* ptr, long long t)
{
	qRegisterMetaType<Qt::SortOrder>();
	QObject::connect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int, Qt::SortOrder)>(&QHeaderView::sortIndicatorChanged), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int, Qt::SortOrder)>(&MyQHeaderView::Signal_SortIndicatorChanged), static_cast<Qt::ConnectionType>(t));
}

void QHeaderView_DisconnectSortIndicatorChanged(void* ptr)
{
	QObject::disconnect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)(int, Qt::SortOrder)>(&QHeaderView::sortIndicatorChanged), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)(int, Qt::SortOrder)>(&MyQHeaderView::Signal_SortIndicatorChanged));
}

void QHeaderView_SortIndicatorChanged(void* ptr, int logicalIndex, long long order)
{
	static_cast<QHeaderView*>(ptr)->sortIndicatorChanged(logicalIndex, static_cast<Qt::SortOrder>(order));
}

long long QHeaderView_SortIndicatorOrder(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->sortIndicatorOrder();
}

int QHeaderView_SortIndicatorSection(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->sortIndicatorSection();
}

char QHeaderView_StretchLastSection(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->stretchLastSection();
}

int QHeaderView_StretchSectionCount(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->stretchSectionCount();
}

void QHeaderView_SwapSections(void* ptr, int first, int second)
{
	static_cast<QHeaderView*>(ptr)->swapSections(first, second);
}

int QHeaderView_VerticalOffset(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->verticalOffset();
}

int QHeaderView_VerticalOffsetDefault(void* ptr)
{
		return static_cast<QHeaderView*>(ptr)->QHeaderView::verticalOffset();
}

int QHeaderView_VisualIndex(void* ptr, int logicalIndex)
{
	return static_cast<QHeaderView*>(ptr)->visualIndex(logicalIndex);
}

int QHeaderView_VisualIndexAt(void* ptr, int position)
{
	return static_cast<QHeaderView*>(ptr)->visualIndexAt(position);
}

void QHeaderView_DestroyQHeaderView(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->~QHeaderView();
}

void QHeaderView_DestroyQHeaderViewDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QHeaderView_IndexAt(void* ptr, void* point)
{
	return new QModelIndex(static_cast<QHeaderView*>(ptr)->indexAt(*static_cast<QPoint*>(point)));
}

void* QHeaderView_IndexAtDefault(void* ptr, void* point)
{
		return new QModelIndex(static_cast<QHeaderView*>(ptr)->QHeaderView::indexAt(*static_cast<QPoint*>(point)));
}

char QHeaderView_IsIndexHidden(void* ptr, void* index)
{
	return static_cast<QHeaderView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}

char QHeaderView_IsIndexHiddenDefault(void* ptr, void* index)
{
		return static_cast<QHeaderView*>(ptr)->QHeaderView::isIndexHidden(*static_cast<QModelIndex*>(index));
}

void* QHeaderView_MoveCursor(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QHeaderView*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void* QHeaderView_MoveCursorDefault(void* ptr, long long cursorAction, long long modifiers)
{
		return new QModelIndex(static_cast<QHeaderView*>(ptr)->QHeaderView::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void QHeaderView_ScrollTo(void* ptr, void* index, long long hint)
{
	static_cast<QHeaderView*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QHeaderView_ScrollToDefault(void* ptr, void* index, long long hint)
{
		static_cast<QHeaderView*>(ptr)->QHeaderView::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void* QHeaderView_VisualRect(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QHeaderView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QHeaderView_VisualRectDefault(void* ptr, void* index)
{
		return ({ QRect tmpValue = static_cast<QHeaderView*>(ptr)->QHeaderView::visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QHeaderView_VisualRegionForSelection(void* ptr, void* selection)
{
	return new QRegion(static_cast<QHeaderView*>(ptr)->visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void* QHeaderView_VisualRegionForSelectionDefault(void* ptr, void* selection)
{
		return new QRegion(static_cast<QHeaderView*>(ptr)->QHeaderView::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

class MyQInputDialog: public QInputDialog
{
public:
	MyQInputDialog(QWidget *parent = Q_NULLPTR, Qt::WindowFlags flags = Qt::WindowFlags()) : QInputDialog(parent, flags) {QInputDialog_QInputDialog_QRegisterMetaType();};
	void done(int result) { callbackQInputDialog_Done(this, result); };
	void Signal_DoubleValueChanged(double value) { callbackQInputDialog_DoubleValueChanged(this, value); };
	void Signal_DoubleValueSelected(double value) { callbackQInputDialog_DoubleValueSelected(this, value); };
	void Signal_IntValueChanged(int value) { callbackQInputDialog_IntValueChanged(this, value); };
	void Signal_IntValueSelected(int value) { callbackQInputDialog_IntValueSelected(this, value); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void setVisible(bool visible) { callbackQDialog_SetVisible(this, visible); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_TextValueChanged(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQInputDialog_TextValueChanged(this, textPacked); };
	void Signal_TextValueSelected(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQInputDialog_TextValueSelected(this, textPacked); };
	 ~MyQInputDialog() { callbackQInputDialog_DestroyQInputDialog(this); };
	void accept() { callbackQDialog_Accept(this); };
	void Signal_Accepted() { callbackQDialog_Accepted(this); };
	void closeEvent(QCloseEvent * e) { callbackQWidget_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	bool eventFilter(QObject * o, QEvent * e) { return callbackQWidget_EventFilter(this, o, e) != 0; };
	int exec() { return callbackQDialog_Exec(this); };
	void Signal_Finished(int result) { callbackQDialog_Finished(this, result); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void reject() { callbackQDialog_Reject(this); };
	void Signal_Rejected() { callbackQDialog_Rejected(this); };
	void resizeEvent(QResizeEvent * vqr) { callbackQWidget_ResizeEvent(this, vqr); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QInputDialog*)
Q_DECLARE_METATYPE(MyQInputDialog*)

int QInputDialog_QInputDialog_QRegisterMetaType(){qRegisterMetaType<QInputDialog*>(); return qRegisterMetaType<MyQInputDialog*>();}

void* QInputDialog_NewQInputDialog(void* parent, long long flags)
{
		return new MyQInputDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}

struct QtWidgets_PackedString QInputDialog_CancelButtonText(void* ptr)
{
	return ({ QByteArray* t24ff21 = new QByteArray(static_cast<QInputDialog*>(ptr)->cancelButtonText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t24ff21->prepend("WHITESPACE").constData()+10), t24ff21->size()-10, t24ff21 }; });
}

struct QtWidgets_PackedString QInputDialog_ComboBoxItems(void* ptr)
{
	return ({ QByteArray* t976d54 = new QByteArray(static_cast<QInputDialog*>(ptr)->comboBoxItems().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t976d54->prepend("WHITESPACE").constData()+10), t976d54->size()-10, t976d54 }; });
}

void QInputDialog_Done(void* ptr, int result)
{
	static_cast<QInputDialog*>(ptr)->done(result);
}

void QInputDialog_DoneDefault(void* ptr, int result)
{
		static_cast<QInputDialog*>(ptr)->QInputDialog::done(result);
}

int QInputDialog_DoubleDecimals(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->doubleDecimals();
}

double QInputDialog_DoubleMaximum(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->doubleMaximum();
}

double QInputDialog_DoubleMinimum(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->doubleMinimum();
}

double QInputDialog_DoubleStep(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->doubleStep();
}

double QInputDialog_DoubleValue(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->doubleValue();
}

void QInputDialog_ConnectDoubleValueChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QInputDialog*>(ptr), static_cast<void (QInputDialog::*)(double)>(&QInputDialog::doubleValueChanged), static_cast<MyQInputDialog*>(ptr), static_cast<void (MyQInputDialog::*)(double)>(&MyQInputDialog::Signal_DoubleValueChanged), static_cast<Qt::ConnectionType>(t));
}

void QInputDialog_DisconnectDoubleValueChanged(void* ptr)
{
	QObject::disconnect(static_cast<QInputDialog*>(ptr), static_cast<void (QInputDialog::*)(double)>(&QInputDialog::doubleValueChanged), static_cast<MyQInputDialog*>(ptr), static_cast<void (MyQInputDialog::*)(double)>(&MyQInputDialog::Signal_DoubleValueChanged));
}

void QInputDialog_DoubleValueChanged(void* ptr, double value)
{
	static_cast<QInputDialog*>(ptr)->doubleValueChanged(value);
}

void QInputDialog_ConnectDoubleValueSelected(void* ptr, long long t)
{
	QObject::connect(static_cast<QInputDialog*>(ptr), static_cast<void (QInputDialog::*)(double)>(&QInputDialog::doubleValueSelected), static_cast<MyQInputDialog*>(ptr), static_cast<void (MyQInputDialog::*)(double)>(&MyQInputDialog::Signal_DoubleValueSelected), static_cast<Qt::ConnectionType>(t));
}

void QInputDialog_DisconnectDoubleValueSelected(void* ptr)
{
	QObject::disconnect(static_cast<QInputDialog*>(ptr), static_cast<void (QInputDialog::*)(double)>(&QInputDialog::doubleValueSelected), static_cast<MyQInputDialog*>(ptr), static_cast<void (MyQInputDialog::*)(double)>(&MyQInputDialog::Signal_DoubleValueSelected));
}

void QInputDialog_DoubleValueSelected(void* ptr, double value)
{
	static_cast<QInputDialog*>(ptr)->doubleValueSelected(value);
}

double QInputDialog_QInputDialog_GetDouble(void* parent, struct QtWidgets_PackedString title, struct QtWidgets_PackedString label, double value, double min, double max, int decimals, char* ok, long long flags)
{
		return QInputDialog::getDouble(static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len), QString::fromUtf8(label.data, label.len), value, min, max, decimals, reinterpret_cast<bool*>(ok), static_cast<Qt::WindowType>(flags));
}

double QInputDialog_QInputDialog_GetDouble2(void* parent, struct QtWidgets_PackedString title, struct QtWidgets_PackedString label, double value, double min, double max, int decimals, char* ok, long long flags, double step)
{
		return QInputDialog::getDouble(static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len), QString::fromUtf8(label.data, label.len), value, min, max, decimals, reinterpret_cast<bool*>(ok), static_cast<Qt::WindowType>(flags), step);
}

int QInputDialog_QInputDialog_GetInt(void* parent, struct QtWidgets_PackedString title, struct QtWidgets_PackedString label, int value, int min, int max, int step, char* ok, long long flags)
{
		return QInputDialog::getInt(static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len), QString::fromUtf8(label.data, label.len), value, min, max, step, reinterpret_cast<bool*>(ok), static_cast<Qt::WindowType>(flags));
}

struct QtWidgets_PackedString QInputDialog_QInputDialog_GetItem(void* parent, struct QtWidgets_PackedString title, struct QtWidgets_PackedString label, struct QtWidgets_PackedString items, int current, char editable, char* ok, long long flags, long long inputMethodHints)
{
		return ({ QByteArray* t589f5f = new QByteArray(QInputDialog::getItem(static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len), QString::fromUtf8(label.data, label.len), QString::fromUtf8(items.data, items.len).split("¡¦!", QString::SkipEmptyParts), current, editable != 0, reinterpret_cast<bool*>(ok), static_cast<Qt::WindowType>(flags), static_cast<Qt::InputMethodHint>(inputMethodHints)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t589f5f->prepend("WHITESPACE").constData()+10), t589f5f->size()-10, t589f5f }; });
}

struct QtWidgets_PackedString QInputDialog_QInputDialog_GetMultiLineText(void* parent, struct QtWidgets_PackedString title, struct QtWidgets_PackedString label, struct QtWidgets_PackedString text, char* ok, long long flags, long long inputMethodHints)
{
		return ({ QByteArray* tb42699 = new QByteArray(QInputDialog::getMultiLineText(static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len), QString::fromUtf8(label.data, label.len), QString::fromUtf8(text.data, text.len), reinterpret_cast<bool*>(ok), static_cast<Qt::WindowType>(flags), static_cast<Qt::InputMethodHint>(inputMethodHints)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tb42699->prepend("WHITESPACE").constData()+10), tb42699->size()-10, tb42699 }; });
}

struct QtWidgets_PackedString QInputDialog_QInputDialog_GetText(void* parent, struct QtWidgets_PackedString title, struct QtWidgets_PackedString label, long long mode, struct QtWidgets_PackedString text, char* ok, long long flags, long long inputMethodHints)
{
		return ({ QByteArray* t03d5ef = new QByteArray(QInputDialog::getText(static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len), QString::fromUtf8(label.data, label.len), static_cast<QLineEdit::EchoMode>(mode), QString::fromUtf8(text.data, text.len), reinterpret_cast<bool*>(ok), static_cast<Qt::WindowType>(flags), static_cast<Qt::InputMethodHint>(inputMethodHints)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t03d5ef->prepend("WHITESPACE").constData()+10), t03d5ef->size()-10, t03d5ef }; });
}

long long QInputDialog_InputMode(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->inputMode();
}

int QInputDialog_IntMaximum(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->intMaximum();
}

int QInputDialog_IntMinimum(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->intMinimum();
}

int QInputDialog_IntStep(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->intStep();
}

int QInputDialog_IntValue(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->intValue();
}

void QInputDialog_ConnectIntValueChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QInputDialog*>(ptr), static_cast<void (QInputDialog::*)(int)>(&QInputDialog::intValueChanged), static_cast<MyQInputDialog*>(ptr), static_cast<void (MyQInputDialog::*)(int)>(&MyQInputDialog::Signal_IntValueChanged), static_cast<Qt::ConnectionType>(t));
}

void QInputDialog_DisconnectIntValueChanged(void* ptr)
{
	QObject::disconnect(static_cast<QInputDialog*>(ptr), static_cast<void (QInputDialog::*)(int)>(&QInputDialog::intValueChanged), static_cast<MyQInputDialog*>(ptr), static_cast<void (MyQInputDialog::*)(int)>(&MyQInputDialog::Signal_IntValueChanged));
}

void QInputDialog_IntValueChanged(void* ptr, int value)
{
	static_cast<QInputDialog*>(ptr)->intValueChanged(value);
}

void QInputDialog_ConnectIntValueSelected(void* ptr, long long t)
{
	QObject::connect(static_cast<QInputDialog*>(ptr), static_cast<void (QInputDialog::*)(int)>(&QInputDialog::intValueSelected), static_cast<MyQInputDialog*>(ptr), static_cast<void (MyQInputDialog::*)(int)>(&MyQInputDialog::Signal_IntValueSelected), static_cast<Qt::ConnectionType>(t));
}

void QInputDialog_DisconnectIntValueSelected(void* ptr)
{
	QObject::disconnect(static_cast<QInputDialog*>(ptr), static_cast<void (QInputDialog::*)(int)>(&QInputDialog::intValueSelected), static_cast<MyQInputDialog*>(ptr), static_cast<void (MyQInputDialog::*)(int)>(&MyQInputDialog::Signal_IntValueSelected));
}

void QInputDialog_IntValueSelected(void* ptr, int value)
{
	static_cast<QInputDialog*>(ptr)->intValueSelected(value);
}

char QInputDialog_IsComboBoxEditable(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->isComboBoxEditable();
}

struct QtWidgets_PackedString QInputDialog_LabelText(void* ptr)
{
	return ({ QByteArray* tf75eaa = new QByteArray(static_cast<QInputDialog*>(ptr)->labelText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tf75eaa->prepend("WHITESPACE").constData()+10), tf75eaa->size()-10, tf75eaa }; });
}

struct QtWidgets_PackedString QInputDialog_OkButtonText(void* ptr)
{
	return ({ QByteArray* t1d4e9a = new QByteArray(static_cast<QInputDialog*>(ptr)->okButtonText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t1d4e9a->prepend("WHITESPACE").constData()+10), t1d4e9a->size()-10, t1d4e9a }; });
}

void QInputDialog_Open(void* ptr, void* receiver, char* member)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(receiver))) {
		static_cast<QInputDialog*>(ptr)->open(static_cast<QGraphicsObject*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(receiver))) {
		static_cast<QInputDialog*>(ptr)->open(static_cast<QGraphicsWidget*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(receiver))) {
		static_cast<QInputDialog*>(ptr)->open(static_cast<QLayout*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(receiver))) {
		static_cast<QInputDialog*>(ptr)->open(static_cast<QWidget*>(receiver), const_cast<const char*>(member));
	} else {
		static_cast<QInputDialog*>(ptr)->open(static_cast<QObject*>(receiver), const_cast<const char*>(member));
	}
}

long long QInputDialog_Options(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->options();
}

void QInputDialog_SetCancelButtonText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QInputDialog*>(ptr)->setCancelButtonText(QString::fromUtf8(text.data, text.len));
}

void QInputDialog_SetComboBoxEditable(void* ptr, char editable)
{
	static_cast<QInputDialog*>(ptr)->setComboBoxEditable(editable != 0);
}

void QInputDialog_SetComboBoxItems(void* ptr, struct QtWidgets_PackedString items)
{
	static_cast<QInputDialog*>(ptr)->setComboBoxItems(QString::fromUtf8(items.data, items.len).split("¡¦!", QString::SkipEmptyParts));
}

void QInputDialog_SetDoubleDecimals(void* ptr, int decimals)
{
	static_cast<QInputDialog*>(ptr)->setDoubleDecimals(decimals);
}

void QInputDialog_SetDoubleMaximum(void* ptr, double max)
{
	static_cast<QInputDialog*>(ptr)->setDoubleMaximum(max);
}

void QInputDialog_SetDoubleMinimum(void* ptr, double min)
{
	static_cast<QInputDialog*>(ptr)->setDoubleMinimum(min);
}

void QInputDialog_SetDoubleRange(void* ptr, double min, double max)
{
	static_cast<QInputDialog*>(ptr)->setDoubleRange(min, max);
}

void QInputDialog_SetDoubleStep(void* ptr, double step)
{
	static_cast<QInputDialog*>(ptr)->setDoubleStep(step);
}

void QInputDialog_SetDoubleValue(void* ptr, double value)
{
	static_cast<QInputDialog*>(ptr)->setDoubleValue(value);
}

void QInputDialog_SetInputMode(void* ptr, long long mode)
{
	static_cast<QInputDialog*>(ptr)->setInputMode(static_cast<QInputDialog::InputMode>(mode));
}

void QInputDialog_SetIntMaximum(void* ptr, int max)
{
	static_cast<QInputDialog*>(ptr)->setIntMaximum(max);
}

void QInputDialog_SetIntMinimum(void* ptr, int min)
{
	static_cast<QInputDialog*>(ptr)->setIntMinimum(min);
}

void QInputDialog_SetIntRange(void* ptr, int min, int max)
{
	static_cast<QInputDialog*>(ptr)->setIntRange(min, max);
}

void QInputDialog_SetIntStep(void* ptr, int step)
{
	static_cast<QInputDialog*>(ptr)->setIntStep(step);
}

void QInputDialog_SetIntValue(void* ptr, int value)
{
	static_cast<QInputDialog*>(ptr)->setIntValue(value);
}

void QInputDialog_SetLabelText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QInputDialog*>(ptr)->setLabelText(QString::fromUtf8(text.data, text.len));
}

void QInputDialog_SetOkButtonText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QInputDialog*>(ptr)->setOkButtonText(QString::fromUtf8(text.data, text.len));
}

void QInputDialog_SetOption(void* ptr, long long option, char on)
{
	static_cast<QInputDialog*>(ptr)->setOption(static_cast<QInputDialog::InputDialogOption>(option), on != 0);
}

void QInputDialog_SetOptions(void* ptr, long long options)
{
	static_cast<QInputDialog*>(ptr)->setOptions(static_cast<QInputDialog::InputDialogOption>(options));
}

void QInputDialog_SetTextEchoMode(void* ptr, long long mode)
{
	static_cast<QInputDialog*>(ptr)->setTextEchoMode(static_cast<QLineEdit::EchoMode>(mode));
}

void QInputDialog_SetTextValue(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QInputDialog*>(ptr)->setTextValue(QString::fromUtf8(text.data, text.len));
}

char QInputDialog_TestOption(void* ptr, long long option)
{
	return static_cast<QInputDialog*>(ptr)->testOption(static_cast<QInputDialog::InputDialogOption>(option));
}

long long QInputDialog_TextEchoMode(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->textEchoMode();
}

struct QtWidgets_PackedString QInputDialog_TextValue(void* ptr)
{
	return ({ QByteArray* t1ee8b9 = new QByteArray(static_cast<QInputDialog*>(ptr)->textValue().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t1ee8b9->prepend("WHITESPACE").constData()+10), t1ee8b9->size()-10, t1ee8b9 }; });
}

void QInputDialog_ConnectTextValueChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QInputDialog*>(ptr), static_cast<void (QInputDialog::*)(const QString &)>(&QInputDialog::textValueChanged), static_cast<MyQInputDialog*>(ptr), static_cast<void (MyQInputDialog::*)(const QString &)>(&MyQInputDialog::Signal_TextValueChanged), static_cast<Qt::ConnectionType>(t));
}

void QInputDialog_DisconnectTextValueChanged(void* ptr)
{
	QObject::disconnect(static_cast<QInputDialog*>(ptr), static_cast<void (QInputDialog::*)(const QString &)>(&QInputDialog::textValueChanged), static_cast<MyQInputDialog*>(ptr), static_cast<void (MyQInputDialog::*)(const QString &)>(&MyQInputDialog::Signal_TextValueChanged));
}

void QInputDialog_TextValueChanged(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QInputDialog*>(ptr)->textValueChanged(QString::fromUtf8(text.data, text.len));
}

void QInputDialog_ConnectTextValueSelected(void* ptr, long long t)
{
	QObject::connect(static_cast<QInputDialog*>(ptr), static_cast<void (QInputDialog::*)(const QString &)>(&QInputDialog::textValueSelected), static_cast<MyQInputDialog*>(ptr), static_cast<void (MyQInputDialog::*)(const QString &)>(&MyQInputDialog::Signal_TextValueSelected), static_cast<Qt::ConnectionType>(t));
}

void QInputDialog_DisconnectTextValueSelected(void* ptr)
{
	QObject::disconnect(static_cast<QInputDialog*>(ptr), static_cast<void (QInputDialog::*)(const QString &)>(&QInputDialog::textValueSelected), static_cast<MyQInputDialog*>(ptr), static_cast<void (MyQInputDialog::*)(const QString &)>(&MyQInputDialog::Signal_TextValueSelected));
}

void QInputDialog_TextValueSelected(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QInputDialog*>(ptr)->textValueSelected(QString::fromUtf8(text.data, text.len));
}

void QInputDialog_DestroyQInputDialog(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->~QInputDialog();
}

void QInputDialog_DestroyQInputDialogDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQItemDelegate: public QItemDelegate
{
public:
	MyQItemDelegate(QObject *parent = Q_NULLPTR) : QItemDelegate(parent) {QItemDelegate_QItemDelegate_QRegisterMetaType();};
	QWidget * createEditor(QWidget * parent, const QStyleOptionViewItem & option, const QModelIndex & index) const { return static_cast<QWidget*>(callbackQAbstractItemDelegate_CreateEditor(const_cast<void*>(static_cast<const void*>(this)), parent, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index))); };
	void drawCheck(QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect, Qt::CheckState state) const { callbackQItemDelegate_DrawCheck(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QRect*>(&rect), state); };
	void drawDecoration(QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect, const QPixmap & pixmap) const { callbackQItemDelegate_DrawDecoration(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QRect*>(&rect), const_cast<QPixmap*>(&pixmap)); };
	void drawDisplay(QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect, const QString & text) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQItemDelegate_DrawDisplay(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QRect*>(&rect), textPacked); };
	void drawFocus(QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect) const { callbackQItemDelegate_DrawFocus(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QRect*>(&rect)); };
	bool editorEvent(QEvent * event, QAbstractItemModel * model, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQAbstractItemDelegate_EditorEvent(this, event, model, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)) != 0; };
	bool eventFilter(QObject * editor, QEvent * event) { return callbackQAbstractItemDelegate_EventFilter(this, editor, event) != 0; };
	void paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQItemDelegate_Paint(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	void setEditorData(QWidget * editor, const QModelIndex & index) const { callbackQAbstractItemDelegate_SetEditorData(const_cast<void*>(static_cast<const void*>(this)), editor, const_cast<QModelIndex*>(&index)); };
	void setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex & index) const { callbackQAbstractItemDelegate_SetModelData(const_cast<void*>(static_cast<const void*>(this)), editor, model, const_cast<QModelIndex*>(&index)); };
	QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex & index) const { return *static_cast<QSize*>(callbackQItemDelegate_SizeHint(const_cast<void*>(static_cast<const void*>(this)), const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index))); };
	void updateEditorGeometry(QWidget * editor, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQAbstractItemDelegate_UpdateEditorGeometry(const_cast<void*>(static_cast<const void*>(this)), editor, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	 ~MyQItemDelegate() { callbackQItemDelegate_DestroyQItemDelegate(this); };
	void Signal_CloseEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemDelegate_CloseEditor(this, editor, hint); };
	void Signal_CommitData(QWidget * editor) { callbackQAbstractItemDelegate_CommitData(this, editor); };
	void destroyEditor(QWidget * editor, const QModelIndex & index) const { callbackQAbstractItemDelegate_DestroyEditor(const_cast<void*>(static_cast<const void*>(this)), editor, const_cast<QModelIndex*>(&index)); };
	bool helpEvent(QHelpEvent * event, QAbstractItemView * view, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQAbstractItemDelegate_HelpEvent(this, event, view, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)) != 0; };
	void Signal_SizeHintChanged(const QModelIndex & index) { callbackQAbstractItemDelegate_SizeHintChanged(this, const_cast<QModelIndex*>(&index)); };
	void childEvent(QChildEvent * event) { callbackQAbstractItemDelegate_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractItemDelegate_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractItemDelegate_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractItemDelegate_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAbstractItemDelegate_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractItemDelegate_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQAbstractItemDelegate_Event(this, e) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractItemDelegate_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAbstractItemDelegate_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAbstractItemDelegate_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QItemDelegate*)
Q_DECLARE_METATYPE(MyQItemDelegate*)

int QItemDelegate_QItemDelegate_QRegisterMetaType(){qRegisterMetaType<QItemDelegate*>(); return qRegisterMetaType<MyQItemDelegate*>();}

void* QItemDelegate_NewQItemDelegate(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQItemDelegate(static_cast<QWindow*>(parent));
	} else {
		return new MyQItemDelegate(static_cast<QObject*>(parent));
	}
}

void QItemDelegate_DrawBackground(void* ptr, void* painter, void* option, void* index)
{
	static_cast<QItemDelegate*>(ptr)->drawBackground(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QItemDelegate_DrawCheck(void* ptr, void* painter, void* option, void* rect, long long state)
{
	static_cast<QItemDelegate*>(ptr)->drawCheck(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QRect*>(rect), static_cast<Qt::CheckState>(state));
}

void QItemDelegate_DrawCheckDefault(void* ptr, void* painter, void* option, void* rect, long long state)
{
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::drawCheck(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QRect*>(rect), static_cast<Qt::CheckState>(state));
}

void QItemDelegate_DrawDecoration(void* ptr, void* painter, void* option, void* rect, void* pixmap)
{
	static_cast<QItemDelegate*>(ptr)->drawDecoration(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QRect*>(rect), *static_cast<QPixmap*>(pixmap));
}

void QItemDelegate_DrawDecorationDefault(void* ptr, void* painter, void* option, void* rect, void* pixmap)
{
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::drawDecoration(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QRect*>(rect), *static_cast<QPixmap*>(pixmap));
}

void QItemDelegate_DrawDisplay(void* ptr, void* painter, void* option, void* rect, struct QtWidgets_PackedString text)
{
	static_cast<QItemDelegate*>(ptr)->drawDisplay(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QRect*>(rect), QString::fromUtf8(text.data, text.len));
}

void QItemDelegate_DrawDisplayDefault(void* ptr, void* painter, void* option, void* rect, struct QtWidgets_PackedString text)
{
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::drawDisplay(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QRect*>(rect), QString::fromUtf8(text.data, text.len));
}

void QItemDelegate_DrawFocus(void* ptr, void* painter, void* option, void* rect)
{
	static_cast<QItemDelegate*>(ptr)->drawFocus(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QRect*>(rect));
}

void QItemDelegate_DrawFocusDefault(void* ptr, void* painter, void* option, void* rect)
{
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::drawFocus(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QRect*>(rect));
}

char QItemDelegate_HasClipping(void* ptr)
{
	return static_cast<QItemDelegate*>(ptr)->hasClipping();
}

void* QItemDelegate_ItemEditorFactory(void* ptr)
{
	return static_cast<QItemDelegate*>(ptr)->itemEditorFactory();
}

void QItemDelegate_Paint(void* ptr, void* painter, void* option, void* index)
{
	static_cast<QItemDelegate*>(ptr)->paint(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QItemDelegate_PaintDefault(void* ptr, void* painter, void* option, void* index)
{
		static_cast<QItemDelegate*>(ptr)->QItemDelegate::paint(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QItemDelegate_SetClipping(void* ptr, char clip)
{
	static_cast<QItemDelegate*>(ptr)->setClipping(clip != 0);
}

void QItemDelegate_SetItemEditorFactory(void* ptr, void* factory)
{
	static_cast<QItemDelegate*>(ptr)->setItemEditorFactory(static_cast<QItemEditorFactory*>(factory));
}

void* QItemDelegate_SizeHint(void* ptr, void* option, void* index)
{
	return ({ QSize tmpValue = static_cast<QItemDelegate*>(ptr)->sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QItemDelegate_SizeHintDefault(void* ptr, void* option, void* index)
{
		return ({ QSize tmpValue = static_cast<QItemDelegate*>(ptr)->QItemDelegate::sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QItemDelegate_DestroyQItemDelegate(void* ptr)
{
	static_cast<QItemDelegate*>(ptr)->~QItemDelegate();
}

void QItemDelegate_DestroyQItemDelegateDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQItemEditorCreatorBase: public QItemEditorCreatorBase
{
public:
	QWidget * createWidget(QWidget * parent) const { return static_cast<QWidget*>(callbackQItemEditorCreatorBase_CreateWidget(const_cast<void*>(static_cast<const void*>(this)), parent)); };
	QByteArray valuePropertyName() const { return *static_cast<QByteArray*>(callbackQItemEditorCreatorBase_ValuePropertyName(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQItemEditorCreatorBase() { callbackQItemEditorCreatorBase_DestroyQItemEditorCreatorBase(this); };
};

Q_DECLARE_METATYPE(QItemEditorCreatorBase*)
Q_DECLARE_METATYPE(MyQItemEditorCreatorBase*)

int QItemEditorCreatorBase_QItemEditorCreatorBase_QRegisterMetaType(){qRegisterMetaType<QItemEditorCreatorBase*>(); return qRegisterMetaType<MyQItemEditorCreatorBase*>();}

void* QItemEditorCreatorBase_CreateWidget(void* ptr, void* parent)
{
		return static_cast<QItemEditorCreatorBase*>(ptr)->createWidget(static_cast<QWidget*>(parent));
}

void* QItemEditorCreatorBase_ValuePropertyName(void* ptr)
{
	return new QByteArray(static_cast<QItemEditorCreatorBase*>(ptr)->valuePropertyName());
}

void QItemEditorCreatorBase_DestroyQItemEditorCreatorBase(void* ptr)
{
	static_cast<QItemEditorCreatorBase*>(ptr)->~QItemEditorCreatorBase();
}

void QItemEditorCreatorBase_DestroyQItemEditorCreatorBaseDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQItemEditorFactory: public QItemEditorFactory
{
public:
	MyQItemEditorFactory() : QItemEditorFactory() {QItemEditorFactory_QItemEditorFactory_QRegisterMetaType();};
	QWidget * createEditor(int userType, QWidget * parent) const { return static_cast<QWidget*>(callbackQItemEditorFactory_CreateEditor(const_cast<void*>(static_cast<const void*>(this)), userType, parent)); };
	QByteArray valuePropertyName(int userType) const { return *static_cast<QByteArray*>(callbackQItemEditorFactory_ValuePropertyName(const_cast<void*>(static_cast<const void*>(this)), userType)); };
	 ~MyQItemEditorFactory() { callbackQItemEditorFactory_DestroyQItemEditorFactory(this); };
};

Q_DECLARE_METATYPE(QItemEditorFactory*)
Q_DECLARE_METATYPE(MyQItemEditorFactory*)

int QItemEditorFactory_QItemEditorFactory_QRegisterMetaType(){qRegisterMetaType<QItemEditorFactory*>(); return qRegisterMetaType<MyQItemEditorFactory*>();}

void* QItemEditorFactory_NewQItemEditorFactory()
{
	return new MyQItemEditorFactory();
}

void* QItemEditorFactory_CreateEditor(void* ptr, int userType, void* parent)
{
		return static_cast<QItemEditorFactory*>(ptr)->createEditor(userType, static_cast<QWidget*>(parent));
}

void* QItemEditorFactory_CreateEditorDefault(void* ptr, int userType, void* parent)
{
		return static_cast<QItemEditorFactory*>(ptr)->QItemEditorFactory::createEditor(userType, static_cast<QWidget*>(parent));
}

void* QItemEditorFactory_QItemEditorFactory_DefaultFactory()
{
	return const_cast<QItemEditorFactory*>(QItemEditorFactory::defaultFactory());
}

void QItemEditorFactory_RegisterEditor(void* ptr, int userType, void* creator)
{
	static_cast<QItemEditorFactory*>(ptr)->registerEditor(userType, static_cast<QItemEditorCreatorBase*>(creator));
}

void QItemEditorFactory_QItemEditorFactory_SetDefaultFactory(void* factory)
{
	QItemEditorFactory::setDefaultFactory(static_cast<QItemEditorFactory*>(factory));
}

void* QItemEditorFactory_ValuePropertyName(void* ptr, int userType)
{
	return new QByteArray(static_cast<QItemEditorFactory*>(ptr)->valuePropertyName(userType));
}

void* QItemEditorFactory_ValuePropertyNameDefault(void* ptr, int userType)
{
		return new QByteArray(static_cast<QItemEditorFactory*>(ptr)->QItemEditorFactory::valuePropertyName(userType));
}

void QItemEditorFactory_DestroyQItemEditorFactory(void* ptr)
{
	static_cast<QItemEditorFactory*>(ptr)->~QItemEditorFactory();
}

void QItemEditorFactory_DestroyQItemEditorFactoryDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QItemEditorFactory___creatorMap_atList(void* ptr, int v, int i)
{
	return ({ QItemEditorCreatorBase * tmp = static_cast<QHash<int, QItemEditorCreatorBase *>*>(ptr)->value(v); if (i == static_cast<QHash<int, QItemEditorCreatorBase *>*>(ptr)->size()-1) { static_cast<QHash<int, QItemEditorCreatorBase *>*>(ptr)->~QHash(); free(ptr); }; tmp; });
}

void QItemEditorFactory___creatorMap_setList(void* ptr, int key, void* i)
{
	static_cast<QHash<int, QItemEditorCreatorBase *>*>(ptr)->insert(key, static_cast<QItemEditorCreatorBase*>(i));
}

void* QItemEditorFactory___creatorMap_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QHash<int, QItemEditorCreatorBase *>();
}

struct QtWidgets_PackedList QItemEditorFactory___creatorMap_keyList(void* ptr)
{
	return ({ QList<int>* tmpValuee608b2 = new QList<int>(static_cast<QHash<int, QItemEditorCreatorBase *>*>(ptr)->keys()); QtWidgets_PackedList { tmpValuee608b2, tmpValuee608b2->size() }; });
}

void* QItemEditorFactory___setCreatorMap__atList(void* ptr, int v, int i)
{
	return ({ QItemEditorCreatorBase * tmp = static_cast<QHash<int, QItemEditorCreatorBase *>*>(ptr)->value(v); if (i == static_cast<QHash<int, QItemEditorCreatorBase *>*>(ptr)->size()-1) { static_cast<QHash<int, QItemEditorCreatorBase *>*>(ptr)->~QHash(); free(ptr); }; tmp; });
}

void QItemEditorFactory___setCreatorMap__setList(void* ptr, int key, void* i)
{
	static_cast<QHash<int, QItemEditorCreatorBase *>*>(ptr)->insert(key, static_cast<QItemEditorCreatorBase*>(i));
}

void* QItemEditorFactory___setCreatorMap__newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QHash<int, QItemEditorCreatorBase *>();
}

struct QtWidgets_PackedList QItemEditorFactory___setCreatorMap__keyList(void* ptr)
{
	return ({ QList<int>* tmpValuee608b2 = new QList<int>(static_cast<QHash<int, QItemEditorCreatorBase *>*>(ptr)->keys()); QtWidgets_PackedList { tmpValuee608b2, tmpValuee608b2->size() }; });
}

int QItemEditorFactory_____creatorMap_keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

int QItemEditorFactory_____setCreatorMap__keyList_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

class MyQKeyEventTransition: public QKeyEventTransition
{
public:
	MyQKeyEventTransition(QState *sourceState = Q_NULLPTR) : QKeyEventTransition(sourceState) {QKeyEventTransition_QKeyEventTransition_QRegisterMetaType();};
	MyQKeyEventTransition(QObject *object, QEvent::Type ty, int key, QState *sourceState = Q_NULLPTR) : QKeyEventTransition(object, ty, key, sourceState) {QKeyEventTransition_QKeyEventTransition_QRegisterMetaType();};
	bool eventTest(QEvent * event) { return callbackQKeyEventTransition_EventTest(this, event) != 0; };
	void onTransition(QEvent * event) { callbackQKeyEventTransition_OnTransition(this, event); };
	 ~MyQKeyEventTransition() { callbackQKeyEventTransition_DestroyQKeyEventTransition(this); };
	bool event(QEvent * e) { return callbackQKeyEventTransition_Event(this, e) != 0; };
	void Signal_TargetStateChanged() { callbackQKeyEventTransition_TargetStateChanged(this); };
	void Signal_TargetStatesChanged() { callbackQKeyEventTransition_TargetStatesChanged(this); };
	void Signal_Triggered() { callbackQKeyEventTransition_Triggered(this); };
	void childEvent(QChildEvent * event) { callbackQKeyEventTransition_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQKeyEventTransition_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQKeyEventTransition_CustomEvent(this, event); };
	void deleteLater() { callbackQKeyEventTransition_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQKeyEventTransition_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQKeyEventTransition_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQKeyEventTransition_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQKeyEventTransition_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQKeyEventTransition_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQKeyEventTransition_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QKeyEventTransition*)
Q_DECLARE_METATYPE(MyQKeyEventTransition*)

int QKeyEventTransition_QKeyEventTransition_QRegisterMetaType(){qRegisterMetaType<QKeyEventTransition*>(); return qRegisterMetaType<MyQKeyEventTransition*>();}

void* QKeyEventTransition_NewQKeyEventTransition(void* sourceState)
{
	return new MyQKeyEventTransition(static_cast<QState*>(sourceState));
}

void* QKeyEventTransition_NewQKeyEventTransition2(void* object, long long ty, int key, void* sourceState)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QAudioSystemPlugin*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QCameraImageCapture*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QDBusPendingCallWatcher*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QExtensionFactory*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QExtensionManager*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QGraphicsObject*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QGraphicsWidget*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QLayout*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QMediaPlaylist*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QMediaRecorder*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QMediaServiceProviderPlugin*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QOffscreenSurface*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QPaintDeviceWindow*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QPdfWriter*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QQuickItem*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QRadioData*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QRemoteObjectPendingCallWatcher*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QScriptExtensionPlugin*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QWidget*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
		return new MyQKeyEventTransition(static_cast<QWindow*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	} else {
		return new MyQKeyEventTransition(static_cast<QObject*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
	}
}

char QKeyEventTransition_EventTestDefault(void* ptr, void* event)
{
		return static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::eventTest(static_cast<QEvent*>(event));
}

int QKeyEventTransition_Key(void* ptr)
{
	return static_cast<QKeyEventTransition*>(ptr)->key();
}

long long QKeyEventTransition_ModifierMask(void* ptr)
{
	return static_cast<QKeyEventTransition*>(ptr)->modifierMask();
}

void QKeyEventTransition_OnTransitionDefault(void* ptr, void* event)
{
		static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::onTransition(static_cast<QEvent*>(event));
}

void QKeyEventTransition_SetKey(void* ptr, int key)
{
	static_cast<QKeyEventTransition*>(ptr)->setKey(key);
}

void QKeyEventTransition_SetModifierMask(void* ptr, long long modifierMask)
{
	static_cast<QKeyEventTransition*>(ptr)->setModifierMask(static_cast<Qt::KeyboardModifier>(modifierMask));
}

void QKeyEventTransition_DestroyQKeyEventTransition(void* ptr)
{
	static_cast<QKeyEventTransition*>(ptr)->~QKeyEventTransition();
}

void QKeyEventTransition_DestroyQKeyEventTransitionDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QKeyEventTransition___animations_atList(void* ptr, int i)
{
	return ({QAbstractAnimation * tmp = static_cast<QList<QAbstractAnimation *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractAnimation *>*>(ptr)->size()-1) { static_cast<QList<QAbstractAnimation *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QKeyEventTransition___animations_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAbstractAnimation *>();
}

void* QKeyEventTransition___setTargetStates_targets_atList(void* ptr, int i)
{
	return ({QAbstractState * tmp = static_cast<QList<QAbstractState *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractState *>*>(ptr)->size()-1) { static_cast<QList<QAbstractState *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QKeyEventTransition___setTargetStates_targets_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAbstractState *>();
}

void* QKeyEventTransition___targetStates_atList(void* ptr, int i)
{
	return ({QAbstractState * tmp = static_cast<QList<QAbstractState *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractState *>*>(ptr)->size()-1) { static_cast<QList<QAbstractState *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QKeyEventTransition___targetStates_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAbstractState *>();
}

void* QKeyEventTransition___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QKeyEventTransition___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QKeyEventTransition___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QKeyEventTransition___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QKeyEventTransition___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QKeyEventTransition___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QKeyEventTransition___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

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

void QKeyEventTransition_DeleteLaterDefault(void* ptr)
{
		static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::deleteLater();
}

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

char QKeyEventTransition_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQKeySequenceEdit: public QKeySequenceEdit
{
public:
	MyQKeySequenceEdit(QWidget *parent = Q_NULLPTR) : QKeySequenceEdit(parent) {QKeySequenceEdit_QKeySequenceEdit_QRegisterMetaType();};
	MyQKeySequenceEdit(const QKeySequence &keySequence, QWidget *parent = Q_NULLPTR) : QKeySequenceEdit(keySequence, parent) {QKeySequenceEdit_QKeySequenceEdit_QRegisterMetaType();};
	void clear() { callbackQKeySequenceEdit_Clear(this); };
	void Signal_EditingFinished() { callbackQKeySequenceEdit_EditingFinished(this); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQWidget_KeyReleaseEvent(this, e); };
	void Signal_KeySequenceChanged(const QKeySequence & keySequence) { callbackQKeySequenceEdit_KeySequenceChanged(this, const_cast<QKeySequence*>(&keySequence)); };
	void setKeySequence(const QKeySequence & keySequence) { callbackQKeySequenceEdit_SetKeySequence(this, const_cast<QKeySequence*>(&keySequence)); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	 ~MyQKeySequenceEdit() { callbackQKeySequenceEdit_DestroyQKeySequenceEdit(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QKeySequenceEdit*)
Q_DECLARE_METATYPE(MyQKeySequenceEdit*)

int QKeySequenceEdit_QKeySequenceEdit_QRegisterMetaType(){qRegisterMetaType<QKeySequenceEdit*>(); return qRegisterMetaType<MyQKeySequenceEdit*>();}

void* QKeySequenceEdit_NewQKeySequenceEdit(void* parent)
{
		return new MyQKeySequenceEdit(static_cast<QWidget*>(parent));
}

void* QKeySequenceEdit_NewQKeySequenceEdit2(void* keySequence, void* parent)
{
		return new MyQKeySequenceEdit(*static_cast<QKeySequence*>(keySequence), static_cast<QWidget*>(parent));
}

void QKeySequenceEdit_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "clear");
}

void QKeySequenceEdit_ClearDefault(void* ptr)
{
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::clear();
}

void QKeySequenceEdit_ConnectEditingFinished(void* ptr, long long t)
{
	QObject::connect(static_cast<QKeySequenceEdit*>(ptr), static_cast<void (QKeySequenceEdit::*)()>(&QKeySequenceEdit::editingFinished), static_cast<MyQKeySequenceEdit*>(ptr), static_cast<void (MyQKeySequenceEdit::*)()>(&MyQKeySequenceEdit::Signal_EditingFinished), static_cast<Qt::ConnectionType>(t));
}

void QKeySequenceEdit_DisconnectEditingFinished(void* ptr)
{
	QObject::disconnect(static_cast<QKeySequenceEdit*>(ptr), static_cast<void (QKeySequenceEdit::*)()>(&QKeySequenceEdit::editingFinished), static_cast<MyQKeySequenceEdit*>(ptr), static_cast<void (MyQKeySequenceEdit::*)()>(&MyQKeySequenceEdit::Signal_EditingFinished));
}

void QKeySequenceEdit_EditingFinished(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->editingFinished();
}

void* QKeySequenceEdit_KeySequence(void* ptr)
{
	return new QKeySequence(static_cast<QKeySequenceEdit*>(ptr)->keySequence());
}

void QKeySequenceEdit_ConnectKeySequenceChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QKeySequenceEdit*>(ptr), static_cast<void (QKeySequenceEdit::*)(const QKeySequence &)>(&QKeySequenceEdit::keySequenceChanged), static_cast<MyQKeySequenceEdit*>(ptr), static_cast<void (MyQKeySequenceEdit::*)(const QKeySequence &)>(&MyQKeySequenceEdit::Signal_KeySequenceChanged), static_cast<Qt::ConnectionType>(t));
}

void QKeySequenceEdit_DisconnectKeySequenceChanged(void* ptr)
{
	QObject::disconnect(static_cast<QKeySequenceEdit*>(ptr), static_cast<void (QKeySequenceEdit::*)(const QKeySequence &)>(&QKeySequenceEdit::keySequenceChanged), static_cast<MyQKeySequenceEdit*>(ptr), static_cast<void (MyQKeySequenceEdit::*)(const QKeySequence &)>(&MyQKeySequenceEdit::Signal_KeySequenceChanged));
}

void QKeySequenceEdit_KeySequenceChanged(void* ptr, void* keySequence)
{
	static_cast<QKeySequenceEdit*>(ptr)->keySequenceChanged(*static_cast<QKeySequence*>(keySequence));
}

void QKeySequenceEdit_SetKeySequence(void* ptr, void* keySequence)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setKeySequence", Q_ARG(const QKeySequence, *static_cast<QKeySequence*>(keySequence)));
}

void QKeySequenceEdit_SetKeySequenceDefault(void* ptr, void* keySequence)
{
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setKeySequence(*static_cast<QKeySequence*>(keySequence));
}

void QKeySequenceEdit_DestroyQKeySequenceEdit(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->~QKeySequenceEdit();
}

void QKeySequenceEdit_DestroyQKeySequenceEditDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQLCDNumber: public QLCDNumber
{
public:
	MyQLCDNumber(QWidget *parent = Q_NULLPTR) : QLCDNumber(parent) {QLCDNumber_QLCDNumber_QRegisterMetaType();};
	MyQLCDNumber(uint numDigits, QWidget *parent = Q_NULLPTR) : QLCDNumber(numDigits, parent) {QLCDNumber_QLCDNumber_QRegisterMetaType();};
	void display(const QString & s) { QByteArray* ta0f149 = new QByteArray(s.toUtf8()); QtWidgets_PackedString sPacked = { const_cast<char*>(ta0f149->prepend("WHITESPACE").constData()+10), ta0f149->size()-10, ta0f149 };callbackQLCDNumber_Display(this, sPacked); };
	void display(int num) { callbackQLCDNumber_Display2(this, num); };
	void display(double num) { callbackQLCDNumber_Display3(this, num); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void Signal_Overflow() { callbackQLCDNumber_Overflow(this); };
	void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
	void setBinMode() { callbackQLCDNumber_SetBinMode(this); };
	void setDecMode() { callbackQLCDNumber_SetDecMode(this); };
	void setHexMode() { callbackQLCDNumber_SetHexMode(this); };
	void setOctMode() { callbackQLCDNumber_SetOctMode(this); };
	void setSmallDecimalPoint(bool vbo) { callbackQLCDNumber_SetSmallDecimalPoint(this, vbo); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQLCDNumber() { callbackQLCDNumber_DestroyQLCDNumber(this); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QLCDNumber*)
Q_DECLARE_METATYPE(MyQLCDNumber*)

int QLCDNumber_QLCDNumber_QRegisterMetaType(){qRegisterMetaType<QLCDNumber*>(); return qRegisterMetaType<MyQLCDNumber*>();}

void* QLCDNumber_NewQLCDNumber(void* parent)
{
		return new MyQLCDNumber(static_cast<QWidget*>(parent));
}

void* QLCDNumber_NewQLCDNumber2(unsigned int numDigits, void* parent)
{
		return new MyQLCDNumber(numDigits, static_cast<QWidget*>(parent));
}

char QLCDNumber_CheckOverflow(void* ptr, double num)
{
	return static_cast<QLCDNumber*>(ptr)->checkOverflow(num);
}

char QLCDNumber_CheckOverflow2(void* ptr, int num)
{
	return static_cast<QLCDNumber*>(ptr)->checkOverflow(num);
}

int QLCDNumber_DigitCount(void* ptr)
{
	return static_cast<QLCDNumber*>(ptr)->digitCount();
}

void QLCDNumber_Display(void* ptr, struct QtWidgets_PackedString s)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "display", Q_ARG(const QString, QString::fromUtf8(s.data, s.len)));
}

void QLCDNumber_DisplayDefault(void* ptr, struct QtWidgets_PackedString s)
{
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::display(QString::fromUtf8(s.data, s.len));
}

void QLCDNumber_Display2(void* ptr, int num)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "display", Q_ARG(int, num));
}

void QLCDNumber_Display2Default(void* ptr, int num)
{
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::display(num);
}

void QLCDNumber_Display3(void* ptr, double num)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "display", Q_ARG(double, num));
}

void QLCDNumber_Display3Default(void* ptr, double num)
{
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::display(num);
}

int QLCDNumber_IntValue(void* ptr)
{
	return static_cast<QLCDNumber*>(ptr)->intValue();
}

long long QLCDNumber_Mode(void* ptr)
{
	return static_cast<QLCDNumber*>(ptr)->mode();
}

void QLCDNumber_ConnectOverflow(void* ptr, long long t)
{
	QObject::connect(static_cast<QLCDNumber*>(ptr), static_cast<void (QLCDNumber::*)()>(&QLCDNumber::overflow), static_cast<MyQLCDNumber*>(ptr), static_cast<void (MyQLCDNumber::*)()>(&MyQLCDNumber::Signal_Overflow), static_cast<Qt::ConnectionType>(t));
}

void QLCDNumber_DisconnectOverflow(void* ptr)
{
	QObject::disconnect(static_cast<QLCDNumber*>(ptr), static_cast<void (QLCDNumber::*)()>(&QLCDNumber::overflow), static_cast<MyQLCDNumber*>(ptr), static_cast<void (MyQLCDNumber::*)()>(&MyQLCDNumber::Signal_Overflow));
}

void QLCDNumber_Overflow(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->overflow();
}

long long QLCDNumber_SegmentStyle(void* ptr)
{
	return static_cast<QLCDNumber*>(ptr)->segmentStyle();
}

void QLCDNumber_SetBinMode(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setBinMode");
}

void QLCDNumber_SetBinModeDefault(void* ptr)
{
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::setBinMode();
}

void QLCDNumber_SetDecMode(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setDecMode");
}

void QLCDNumber_SetDecModeDefault(void* ptr)
{
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::setDecMode();
}

void QLCDNumber_SetDigitCount(void* ptr, int numDigits)
{
	static_cast<QLCDNumber*>(ptr)->setDigitCount(numDigits);
}

void QLCDNumber_SetHexMode(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setHexMode");
}

void QLCDNumber_SetHexModeDefault(void* ptr)
{
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::setHexMode();
}

void QLCDNumber_SetMode(void* ptr, long long vql)
{
	static_cast<QLCDNumber*>(ptr)->setMode(static_cast<QLCDNumber::Mode>(vql));
}

void QLCDNumber_SetOctMode(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setOctMode");
}

void QLCDNumber_SetOctModeDefault(void* ptr)
{
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::setOctMode();
}

void QLCDNumber_SetSegmentStyle(void* ptr, long long vql)
{
	static_cast<QLCDNumber*>(ptr)->setSegmentStyle(static_cast<QLCDNumber::SegmentStyle>(vql));
}

void QLCDNumber_SetSmallDecimalPoint(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setSmallDecimalPoint", Q_ARG(bool, vbo != 0));
}

void QLCDNumber_SetSmallDecimalPointDefault(void* ptr, char vbo)
{
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::setSmallDecimalPoint(vbo != 0);
}

char QLCDNumber_SmallDecimalPoint(void* ptr)
{
	return static_cast<QLCDNumber*>(ptr)->smallDecimalPoint();
}

double QLCDNumber_Value(void* ptr)
{
	return static_cast<QLCDNumber*>(ptr)->value();
}

void QLCDNumber_DestroyQLCDNumber(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->~QLCDNumber();
}

void QLCDNumber_DestroyQLCDNumberDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQLabel: public QLabel
{
public:
	MyQLabel(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QLabel(parent, ff) {QLabel_QLabel_QRegisterMetaType();};
	MyQLabel(const QString &text, QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QLabel(text, parent, ff) {QLabel_QLabel_QRegisterMetaType();};
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void clear() { callbackQLabel_Clear(this); };
	void contextMenuEvent(QContextMenuEvent * ev) { callbackQWidget_ContextMenuEvent(this, ev); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void focusInEvent(QFocusEvent * ev) { callbackQWidget_FocusInEvent(this, ev); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * ev) { callbackQWidget_FocusOutEvent(this, ev); };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void keyPressEvent(QKeyEvent * ev) { callbackQWidget_KeyPressEvent(this, ev); };
	void Signal_LinkActivated(const QString & link) { QByteArray* t4f0aa5 = new QByteArray(link.toUtf8()); QtWidgets_PackedString linkPacked = { const_cast<char*>(t4f0aa5->prepend("WHITESPACE").constData()+10), t4f0aa5->size()-10, t4f0aa5 };callbackQLabel_LinkActivated(this, linkPacked); };
	void Signal_LinkHovered(const QString & link) { QByteArray* t4f0aa5 = new QByteArray(link.toUtf8()); QtWidgets_PackedString linkPacked = { const_cast<char*>(t4f0aa5->prepend("WHITESPACE").constData()+10), t4f0aa5->size()-10, t4f0aa5 };callbackQLabel_LinkHovered(this, linkPacked); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseMoveEvent(QMouseEvent * ev) { callbackQWidget_MouseMoveEvent(this, ev); };
	void mousePressEvent(QMouseEvent * ev) { callbackQWidget_MousePressEvent(this, ev); };
	void mouseReleaseEvent(QMouseEvent * ev) { callbackQWidget_MouseReleaseEvent(this, ev); };
	void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
	void setMovie(QMovie * movie) { callbackQLabel_SetMovie(this, movie); };
	void setNum(int num) { callbackQLabel_SetNum(this, num); };
	void setNum(double num) { callbackQLabel_SetNum2(this, num); };
	void setPicture(const QPicture & picture) { callbackQLabel_SetPicture(this, const_cast<QPicture*>(&picture)); };
	void setPixmap(const QPixmap & vqp) { callbackQLabel_SetPixmap(this, const_cast<QPixmap*>(&vqp)); };
	void setText(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQLabel_SetText(this, vqsPacked); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQLabel() { callbackQLabel_DestroyQLabel(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QLabel*)
Q_DECLARE_METATYPE(MyQLabel*)

int QLabel_QLabel_QRegisterMetaType(){qRegisterMetaType<QLabel*>(); return qRegisterMetaType<MyQLabel*>();}

void* QLabel_NewQLabel(void* parent, long long ff)
{
		return new MyQLabel(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}

void* QLabel_NewQLabel2(struct QtWidgets_PackedString text, void* parent, long long ff)
{
		return new MyQLabel(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}

long long QLabel_Alignment(void* ptr)
{
	return static_cast<QLabel*>(ptr)->alignment();
}

void* QLabel_Buddy(void* ptr)
{
	return static_cast<QLabel*>(ptr)->buddy();
}

void QLabel_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "clear");
}

void QLabel_ClearDefault(void* ptr)
{
		static_cast<QLabel*>(ptr)->QLabel::clear();
}

char QLabel_HasScaledContents(void* ptr)
{
	return static_cast<QLabel*>(ptr)->hasScaledContents();
}

char QLabel_HasSelectedText(void* ptr)
{
	return static_cast<QLabel*>(ptr)->hasSelectedText();
}

int QLabel_Indent(void* ptr)
{
	return static_cast<QLabel*>(ptr)->indent();
}

void QLabel_ConnectLinkActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QLabel*>(ptr), static_cast<void (QLabel::*)(const QString &)>(&QLabel::linkActivated), static_cast<MyQLabel*>(ptr), static_cast<void (MyQLabel::*)(const QString &)>(&MyQLabel::Signal_LinkActivated), static_cast<Qt::ConnectionType>(t));
}

void QLabel_DisconnectLinkActivated(void* ptr)
{
	QObject::disconnect(static_cast<QLabel*>(ptr), static_cast<void (QLabel::*)(const QString &)>(&QLabel::linkActivated), static_cast<MyQLabel*>(ptr), static_cast<void (MyQLabel::*)(const QString &)>(&MyQLabel::Signal_LinkActivated));
}

void QLabel_LinkActivated(void* ptr, struct QtWidgets_PackedString link)
{
	static_cast<QLabel*>(ptr)->linkActivated(QString::fromUtf8(link.data, link.len));
}

void QLabel_ConnectLinkHovered(void* ptr, long long t)
{
	QObject::connect(static_cast<QLabel*>(ptr), static_cast<void (QLabel::*)(const QString &)>(&QLabel::linkHovered), static_cast<MyQLabel*>(ptr), static_cast<void (MyQLabel::*)(const QString &)>(&MyQLabel::Signal_LinkHovered), static_cast<Qt::ConnectionType>(t));
}

void QLabel_DisconnectLinkHovered(void* ptr)
{
	QObject::disconnect(static_cast<QLabel*>(ptr), static_cast<void (QLabel::*)(const QString &)>(&QLabel::linkHovered), static_cast<MyQLabel*>(ptr), static_cast<void (MyQLabel::*)(const QString &)>(&MyQLabel::Signal_LinkHovered));
}

void QLabel_LinkHovered(void* ptr, struct QtWidgets_PackedString link)
{
	static_cast<QLabel*>(ptr)->linkHovered(QString::fromUtf8(link.data, link.len));
}

int QLabel_Margin(void* ptr)
{
	return static_cast<QLabel*>(ptr)->margin();
}

void* QLabel_Movie(void* ptr)
{
	return static_cast<QLabel*>(ptr)->movie();
}

char QLabel_OpenExternalLinks(void* ptr)
{
	return static_cast<QLabel*>(ptr)->openExternalLinks();
}

void* QLabel_Picture(void* ptr)
{
	return const_cast<QPicture*>(static_cast<QLabel*>(ptr)->picture());
}

void* QLabel_Pixmap(void* ptr)
{
	return const_cast<QPixmap*>(static_cast<QLabel*>(ptr)->pixmap());
}

struct QtWidgets_PackedString QLabel_SelectedText(void* ptr)
{
	return ({ QByteArray* t8b2afb = new QByteArray(static_cast<QLabel*>(ptr)->selectedText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t8b2afb->prepend("WHITESPACE").constData()+10), t8b2afb->size()-10, t8b2afb }; });
}

int QLabel_SelectionStart(void* ptr)
{
	return static_cast<QLabel*>(ptr)->selectionStart();
}

void QLabel_SetAlignment(void* ptr, long long vqt)
{
	static_cast<QLabel*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(vqt));
}

void QLabel_SetBuddy(void* ptr, void* buddy)
{
		static_cast<QLabel*>(ptr)->setBuddy(static_cast<QWidget*>(buddy));
}

void QLabel_SetIndent(void* ptr, int vin)
{
	static_cast<QLabel*>(ptr)->setIndent(vin);
}

void QLabel_SetMargin(void* ptr, int vin)
{
	static_cast<QLabel*>(ptr)->setMargin(vin);
}

void QLabel_SetMovie(void* ptr, void* movie)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setMovie", Q_ARG(QMovie*, static_cast<QMovie*>(movie)));
}

void QLabel_SetMovieDefault(void* ptr, void* movie)
{
		static_cast<QLabel*>(ptr)->QLabel::setMovie(static_cast<QMovie*>(movie));
}

void QLabel_SetNum(void* ptr, int num)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setNum", Q_ARG(int, num));
}

void QLabel_SetNumDefault(void* ptr, int num)
{
		static_cast<QLabel*>(ptr)->QLabel::setNum(num);
}

void QLabel_SetNum2(void* ptr, double num)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setNum", Q_ARG(double, num));
}

void QLabel_SetNum2Default(void* ptr, double num)
{
		static_cast<QLabel*>(ptr)->QLabel::setNum(num);
}

void QLabel_SetOpenExternalLinks(void* ptr, char open)
{
	static_cast<QLabel*>(ptr)->setOpenExternalLinks(open != 0);
}

void QLabel_SetPicture(void* ptr, void* picture)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setPicture", Q_ARG(const QPicture, *static_cast<QPicture*>(picture)));
}

void QLabel_SetPictureDefault(void* ptr, void* picture)
{
		static_cast<QLabel*>(ptr)->QLabel::setPicture(*static_cast<QPicture*>(picture));
}

void QLabel_SetPixmap(void* ptr, void* vqp)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setPixmap", Q_ARG(const QPixmap, *static_cast<QPixmap*>(vqp)));
}

void QLabel_SetPixmapDefault(void* ptr, void* vqp)
{
		static_cast<QLabel*>(ptr)->QLabel::setPixmap(*static_cast<QPixmap*>(vqp));
}

void QLabel_SetScaledContents(void* ptr, char vbo)
{
	static_cast<QLabel*>(ptr)->setScaledContents(vbo != 0);
}

void QLabel_SetSelection(void* ptr, int start, int length)
{
	static_cast<QLabel*>(ptr)->setSelection(start, length);
}

void QLabel_SetText(void* ptr, struct QtWidgets_PackedString vqs)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setText", Q_ARG(const QString, QString::fromUtf8(vqs.data, vqs.len)));
}

void QLabel_SetTextDefault(void* ptr, struct QtWidgets_PackedString vqs)
{
		static_cast<QLabel*>(ptr)->QLabel::setText(QString::fromUtf8(vqs.data, vqs.len));
}

void QLabel_SetTextFormat(void* ptr, long long vqt)
{
	static_cast<QLabel*>(ptr)->setTextFormat(static_cast<Qt::TextFormat>(vqt));
}

void QLabel_SetTextInteractionFlags(void* ptr, long long flags)
{
	static_cast<QLabel*>(ptr)->setTextInteractionFlags(static_cast<Qt::TextInteractionFlag>(flags));
}

void QLabel_SetWordWrap(void* ptr, char on)
{
	static_cast<QLabel*>(ptr)->setWordWrap(on != 0);
}

struct QtWidgets_PackedString QLabel_Text(void* ptr)
{
	return ({ QByteArray* t0d779d = new QByteArray(static_cast<QLabel*>(ptr)->text().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t0d779d->prepend("WHITESPACE").constData()+10), t0d779d->size()-10, t0d779d }; });
}

long long QLabel_TextFormat(void* ptr)
{
	return static_cast<QLabel*>(ptr)->textFormat();
}

long long QLabel_TextInteractionFlags(void* ptr)
{
	return static_cast<QLabel*>(ptr)->textInteractionFlags();
}

char QLabel_WordWrap(void* ptr)
{
	return static_cast<QLabel*>(ptr)->wordWrap();
}

void QLabel_DestroyQLabel(void* ptr)
{
	static_cast<QLabel*>(ptr)->~QLabel();
}

void QLabel_DestroyQLabelDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQLayout: public QLayout
{
public:
	MyQLayout(QWidget *parent) : QLayout(parent) {QLayout_QLayout_QRegisterMetaType();};
	MyQLayout() : QLayout() {QLayout_QLayout_QRegisterMetaType();};
	void addItem(QLayoutItem * item) { callbackQLayout_AddItem(this, item); };
	void childEvent(QChildEvent * e) { callbackQLayout_ChildEvent(this, e); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayoutItem_ControlTypes(const_cast<void*>(static_cast<const void*>(this)))); };
	int count() const { return callbackQLayout_Count(const_cast<void*>(static_cast<const void*>(this))); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQLayout_ExpandingDirections(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQLayout_Geometry(const_cast<void*>(static_cast<const void*>(this)))); };
	int indexOf(QWidget * widget) const { return callbackQLayout_IndexOf(const_cast<void*>(static_cast<const void*>(this)), widget); };
	void invalidate() { callbackQLayoutItem_Invalidate(this); };
	bool isEmpty() const { return callbackQLayout_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQLayout_ItemAt(const_cast<void*>(static_cast<const void*>(this)), index)); };
	QLayout * layout() { return static_cast<QLayout*>(callbackQLayoutItem_Layout(this)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQLayout_MaximumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQLayout_MinimumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	void setGeometry(const QRect & r) { callbackQLayout_SetGeometry(this, const_cast<QRect*>(&r)); };
	QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQLayout_TakeAt(this, index)); };
	void connectNotify(const QMetaMethod & sign) { callbackQLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQLayout_CustomEvent(this, event); };
	void deleteLater() { callbackQLayout_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQLayout_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQLayout_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQLayout_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLayout_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQLayout_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQLayout_TimerEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQLayoutItem_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int vin) const { return callbackQLayoutItem_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), vin); };
	int minimumHeightForWidth(int w) const { return callbackQLayoutItem_MinimumHeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQLayout_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayoutItem_SpacerItem(this)); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQLayoutItem_Widget(this)); };
};

Q_DECLARE_METATYPE(QLayout*)
Q_DECLARE_METATYPE(MyQLayout*)

int QLayout_QLayout_QRegisterMetaType(){qRegisterMetaType<QLayout*>(); return qRegisterMetaType<MyQLayout*>();}

void* QLayout_NewQLayout(void* parent)
{
	return new MyQLayout(static_cast<QWidget*>(parent));
}

void* QLayout_NewQLayout2()
{
	return new MyQLayout();
}

char QLayout_Activate(void* ptr)
{
		return static_cast<QLayout*>(ptr)->activate();
}

void QLayout_AddChildLayout(void* ptr, void* l)
{
		static_cast<QLayout*>(ptr)->addChildLayout(static_cast<QLayout*>(l));
}

void QLayout_AddChildWidget(void* ptr, void* w)
{
		static_cast<QLayout*>(ptr)->addChildWidget(static_cast<QWidget*>(w));
}

void QLayout_AddItem(void* ptr, void* item)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
		static_cast<QLayout*>(ptr)->addItem(static_cast<QLayout*>(item));
	} else {
		static_cast<QLayout*>(ptr)->addItem(static_cast<QLayoutItem*>(item));
	}
}

void QLayout_AddWidget(void* ptr, void* w)
{
		static_cast<QLayout*>(ptr)->addWidget(static_cast<QWidget*>(w));
}

void* QLayout_AlignmentRect(void* ptr, void* r)
{
		return ({ QRect tmpValue = static_cast<QLayout*>(ptr)->alignmentRect(*static_cast<QRect*>(r)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QLayout_ChildEvent(void* ptr, void* e)
{
		static_cast<QLayout*>(ptr)->childEvent(static_cast<QChildEvent*>(e));
}

void QLayout_ChildEventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedLayout*>(ptr)->QStackedLayout::childEvent(static_cast<QChildEvent*>(e));
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QFormLayout*>(ptr)->QFormLayout::childEvent(static_cast<QChildEvent*>(e));
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::childEvent(static_cast<QChildEvent*>(e));
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::childEvent(static_cast<QChildEvent*>(e));
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QBoxLayout*>(ptr)->QBoxLayout::childEvent(static_cast<QChildEvent*>(e));
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QGridLayout*>(ptr)->QGridLayout::childEvent(static_cast<QChildEvent*>(e));
	} else {
		static_cast<QLayout*>(ptr)->QLayout::childEvent(static_cast<QChildEvent*>(e));
	}
}

void* QLayout_QLayout_ClosestAcceptableSize(void* widget, void* size)
{
		return ({ QSize tmpValue = QLayout::closestAcceptableSize(static_cast<QWidget*>(widget), *static_cast<QSize*>(size)); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QLayout_ContentsMargins(void* ptr)
{
		return ({ QMargins tmpValue = static_cast<QLayout*>(ptr)->contentsMargins(); new QMargins(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}

void* QLayout_ContentsRect(void* ptr)
{
		return ({ QRect tmpValue = static_cast<QLayout*>(ptr)->contentsRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

int QLayout_Count(void* ptr)
{
		return static_cast<QLayout*>(ptr)->count();
}

long long QLayout_ExpandingDirections(void* ptr)
{
		return static_cast<QLayout*>(ptr)->expandingDirections();
}

long long QLayout_ExpandingDirectionsDefault(void* ptr)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::expandingDirections();
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFormLayout*>(ptr)->QFormLayout::expandingDirections();
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::expandingDirections();
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::expandingDirections();
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::expandingDirections();
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGridLayout*>(ptr)->QGridLayout::expandingDirections();
	} else {
		return static_cast<QLayout*>(ptr)->QLayout::expandingDirections();
	}
}

void* QLayout_Geometry(void* ptr)
{
		return ({ QRect tmpValue = static_cast<QLayout*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QLayout_GeometryDefault(void* ptr)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QStackedLayout*>(ptr)->QStackedLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QFormLayout*>(ptr)->QFormLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QBoxLayout*>(ptr)->QBoxLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QGridLayout*>(ptr)->QGridLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRect tmpValue = static_cast<QLayout*>(ptr)->QLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void QLayout_GetContentsMargins(void* ptr, int left, int top, int right, int bottom)
{
		static_cast<QLayout*>(ptr)->getContentsMargins(&left, &top, &right, &bottom);
}

int QLayout_IndexOf(void* ptr, void* widget)
{
		return static_cast<QLayout*>(ptr)->indexOf(static_cast<QWidget*>(widget));
}

int QLayout_IndexOfDefault(void* ptr, void* widget)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::indexOf(static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFormLayout*>(ptr)->QFormLayout::indexOf(static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::indexOf(static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::indexOf(static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::indexOf(static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGridLayout*>(ptr)->QGridLayout::indexOf(static_cast<QWidget*>(widget));
	} else {
		return static_cast<QLayout*>(ptr)->QLayout::indexOf(static_cast<QWidget*>(widget));
	}
}

int QLayout_IndexOf2(void* ptr, void* layoutItem)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(layoutItem))) {
		return static_cast<QLayout*>(ptr)->indexOf(static_cast<QLayout*>(layoutItem));
	} else {
		return static_cast<QLayout*>(ptr)->indexOf(static_cast<QLayoutItem*>(layoutItem));
	}
}

char QLayout_IsEmpty(void* ptr)
{
		return static_cast<QLayout*>(ptr)->isEmpty();
}

char QLayout_IsEmptyDefault(void* ptr)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::isEmpty();
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFormLayout*>(ptr)->QFormLayout::isEmpty();
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::isEmpty();
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::isEmpty();
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::isEmpty();
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGridLayout*>(ptr)->QGridLayout::isEmpty();
	} else {
		return static_cast<QLayout*>(ptr)->QLayout::isEmpty();
	}
}

char QLayout_IsEnabled(void* ptr)
{
		return static_cast<QLayout*>(ptr)->isEnabled();
}

void* QLayout_ItemAt(void* ptr, int index)
{
		return static_cast<QLayout*>(ptr)->itemAt(index);
}

void* QLayout_MaximumSize(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QLayout*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QLayout_MaximumSizeDefault(void* ptr)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QStackedLayout*>(ptr)->QStackedLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QFormLayout*>(ptr)->QFormLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QBoxLayout*>(ptr)->QBoxLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QGridLayout*>(ptr)->QGridLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QLayout*>(ptr)->QLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void* QLayout_MenuBar(void* ptr)
{
		return static_cast<QLayout*>(ptr)->menuBar();
}

void* QLayout_MinimumSize(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QLayout*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QLayout_MinimumSizeDefault(void* ptr)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QStackedLayout*>(ptr)->QStackedLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QFormLayout*>(ptr)->QFormLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QBoxLayout*>(ptr)->QBoxLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QGridLayout*>(ptr)->QGridLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QLayout*>(ptr)->QLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void* QLayout_ParentWidget(void* ptr)
{
		return static_cast<QLayout*>(ptr)->parentWidget();
}

void QLayout_RemoveItem(void* ptr, void* item)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
		static_cast<QLayout*>(ptr)->removeItem(static_cast<QLayout*>(item));
	} else {
		static_cast<QLayout*>(ptr)->removeItem(static_cast<QLayoutItem*>(item));
	}
}

void QLayout_RemoveWidget(void* ptr, void* widget)
{
		static_cast<QLayout*>(ptr)->removeWidget(static_cast<QWidget*>(widget));
}

void* QLayout_ReplaceWidget(void* ptr, void* from, void* to, long long options)
{
		return static_cast<QLayout*>(ptr)->replaceWidget(static_cast<QWidget*>(from), static_cast<QWidget*>(to), static_cast<Qt::FindChildOption>(options));
}

char QLayout_SetAlignment(void* ptr, void* w, long long alignment)
{
		return static_cast<QLayout*>(ptr)->setAlignment(static_cast<QWidget*>(w), static_cast<Qt::AlignmentFlag>(alignment));
}

char QLayout_SetAlignment2(void* ptr, void* l, long long alignment)
{
		return static_cast<QLayout*>(ptr)->setAlignment(static_cast<QLayout*>(l), static_cast<Qt::AlignmentFlag>(alignment));
}

void QLayout_SetContentsMargins(void* ptr, int left, int top, int right, int bottom)
{
		static_cast<QLayout*>(ptr)->setContentsMargins(left, top, right, bottom);
}

void QLayout_SetContentsMargins2(void* ptr, void* margins)
{
		static_cast<QLayout*>(ptr)->setContentsMargins(*static_cast<QMargins*>(margins));
}

void QLayout_SetEnabled(void* ptr, char enable)
{
		static_cast<QLayout*>(ptr)->setEnabled(enable != 0);
}

void QLayout_SetGeometry(void* ptr, void* r)
{
		static_cast<QLayout*>(ptr)->setGeometry(*static_cast<QRect*>(r));
}

void QLayout_SetGeometryDefault(void* ptr, void* r)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedLayout*>(ptr)->QStackedLayout::setGeometry(*static_cast<QRect*>(r));
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QFormLayout*>(ptr)->QFormLayout::setGeometry(*static_cast<QRect*>(r));
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::setGeometry(*static_cast<QRect*>(r));
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::setGeometry(*static_cast<QRect*>(r));
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QBoxLayout*>(ptr)->QBoxLayout::setGeometry(*static_cast<QRect*>(r));
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QGridLayout*>(ptr)->QGridLayout::setGeometry(*static_cast<QRect*>(r));
	} else {
		static_cast<QLayout*>(ptr)->QLayout::setGeometry(*static_cast<QRect*>(r));
	}
}

void QLayout_SetMenuBar(void* ptr, void* widget)
{
		static_cast<QLayout*>(ptr)->setMenuBar(static_cast<QWidget*>(widget));
}

void QLayout_SetSizeConstraint(void* ptr, long long vql)
{
		static_cast<QLayout*>(ptr)->setSizeConstraint(static_cast<QLayout::SizeConstraint>(vql));
}

void QLayout_SetSpacing(void* ptr, int vin)
{
		static_cast<QLayout*>(ptr)->setSpacing(vin);
}

long long QLayout_SizeConstraint(void* ptr)
{
		return static_cast<QLayout*>(ptr)->sizeConstraint();
}

int QLayout_Spacing(void* ptr)
{
		return static_cast<QLayout*>(ptr)->spacing();
}

void* QLayout_TakeAt(void* ptr, int index)
{
		return static_cast<QLayout*>(ptr)->takeAt(index);
}

void QLayout_Update(void* ptr)
{
		static_cast<QLayout*>(ptr)->update();
}

void* QLayout___children_atList(void* ptr, int i)
{
		return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QLayout___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QLayout___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QLayout___findChildren_atList(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QLayout___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QLayout___findChildren_atList3(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QLayout___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void QLayout_ConnectNotify(void* ptr, void* sign)
{
		static_cast<QLayout*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QLayout_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedLayout*>(ptr)->QStackedLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QFormLayout*>(ptr)->QFormLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QBoxLayout*>(ptr)->QBoxLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QGridLayout*>(ptr)->QGridLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QLayout*>(ptr)->QLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QLayout_CustomEvent(void* ptr, void* event)
{
		static_cast<QLayout*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QLayout_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedLayout*>(ptr)->QStackedLayout::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QFormLayout*>(ptr)->QFormLayout::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QBoxLayout*>(ptr)->QBoxLayout::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QGridLayout*>(ptr)->QGridLayout::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QLayout*>(ptr)->QLayout::customEvent(static_cast<QEvent*>(event));
	}
}

void QLayout_DeleteLater(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QLayout*>(ptr), "deleteLater");
}

void QLayout_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedLayout*>(ptr)->QStackedLayout::deleteLater();
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QFormLayout*>(ptr)->QFormLayout::deleteLater();
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::deleteLater();
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::deleteLater();
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QBoxLayout*>(ptr)->QBoxLayout::deleteLater();
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QGridLayout*>(ptr)->QGridLayout::deleteLater();
	} else {
		static_cast<QLayout*>(ptr)->QLayout::deleteLater();
	}
}

void QLayout_DisconnectNotify(void* ptr, void* sign)
{
		static_cast<QLayout*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QLayout_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedLayout*>(ptr)->QStackedLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QFormLayout*>(ptr)->QFormLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QBoxLayout*>(ptr)->QBoxLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QGridLayout*>(ptr)->QGridLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QLayout*>(ptr)->QLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

char QLayout_Event(void* ptr, void* e)
{
		return static_cast<QLayout*>(ptr)->event(static_cast<QEvent*>(e));
}

char QLayout_EventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFormLayout*>(ptr)->QFormLayout::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGridLayout*>(ptr)->QGridLayout::event(static_cast<QEvent*>(e));
	} else {
		return static_cast<QLayout*>(ptr)->QLayout::event(static_cast<QEvent*>(e));
	}
}

char QLayout_EventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QLayout*>(ptr)->eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QLayout*>(ptr)->eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QLayout*>(ptr)->eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QLayout*>(ptr)->eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

char QLayout_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QStackedLayout*>(ptr)->QStackedLayout::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QStackedLayout*>(ptr)->QStackedLayout::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QStackedLayout*>(ptr)->QStackedLayout::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QStackedLayout*>(ptr)->QStackedLayout::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QStackedLayout*>(ptr)->QStackedLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QFormLayout*>(ptr)->QFormLayout::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QFormLayout*>(ptr)->QFormLayout::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QFormLayout*>(ptr)->QFormLayout::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QFormLayout*>(ptr)->QFormLayout::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QFormLayout*>(ptr)->QFormLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QBoxLayout*>(ptr)->QBoxLayout::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QBoxLayout*>(ptr)->QBoxLayout::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QBoxLayout*>(ptr)->QBoxLayout::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QBoxLayout*>(ptr)->QBoxLayout::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QBoxLayout*>(ptr)->QBoxLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGridLayout*>(ptr)->QGridLayout::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGridLayout*>(ptr)->QGridLayout::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGridLayout*>(ptr)->QGridLayout::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGridLayout*>(ptr)->QGridLayout::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGridLayout*>(ptr)->QGridLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QLayout*>(ptr)->QLayout::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QLayout*>(ptr)->QLayout::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QLayout*>(ptr)->QLayout::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QLayout*>(ptr)->QLayout::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QLayout*>(ptr)->QLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void* QLayout_MetaObject(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QLayout*>(ptr)->metaObject());
}

void* QLayout_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QStackedLayout*>(ptr)->QStackedLayout::metaObject());
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QFormLayout*>(ptr)->QFormLayout::metaObject());
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::metaObject());
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::metaObject());
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QBoxLayout*>(ptr)->QBoxLayout::metaObject());
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QGridLayout*>(ptr)->QGridLayout::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QLayout*>(ptr)->QLayout::metaObject());
	}
}

void QLayout_TimerEvent(void* ptr, void* event)
{
		static_cast<QLayout*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QLayout_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedLayout*>(ptr)->QStackedLayout::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QFormLayout*>(ptr)->QFormLayout::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QBoxLayout*>(ptr)->QBoxLayout::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QGridLayout*>(ptr)->QGridLayout::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QLayout*>(ptr)->QLayout::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

void* QLayout_SizeHint(void* ptr)
{
	Q_UNUSED(ptr);
	
}

void* QLayout_SizeHintDefault(void* ptr)
{
	if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QStackedLayout*>(ptr)->QStackedLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QFormLayout*>(ptr)->QFormLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QBoxLayout*>(ptr)->QBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QGridLayout*>(ptr)->QGridLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
	
	}
}

class MyQLayoutItem: public QLayoutItem
{
public:
	MyQLayoutItem(Qt::Alignment alignment = Qt::Alignment()) : QLayoutItem(alignment) {QLayoutItem_QLayoutItem_QRegisterMetaType();};
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayoutItem_ControlTypes(const_cast<void*>(static_cast<const void*>(this)))); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQLayoutItem_ExpandingDirections(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQLayoutItem_Geometry(const_cast<void*>(static_cast<const void*>(this)))); };
	bool hasHeightForWidth() const { return callbackQLayoutItem_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int vin) const { return callbackQLayoutItem_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), vin); };
	void invalidate() { callbackQLayoutItem_Invalidate(this); };
	bool isEmpty() const { return callbackQLayoutItem_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QLayout * layout() { return static_cast<QLayout*>(callbackQLayoutItem_Layout(this)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQLayoutItem_MaximumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	int minimumHeightForWidth(int w) const { return callbackQLayoutItem_MinimumHeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQLayoutItem_MinimumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	void setGeometry(const QRect & r) { callbackQLayoutItem_SetGeometry(this, const_cast<QRect*>(&r)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQLayoutItem_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayoutItem_SpacerItem(this)); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQLayoutItem_Widget(this)); };
	 ~MyQLayoutItem() { callbackQLayoutItem_DestroyQLayoutItem(this); };
};

Q_DECLARE_METATYPE(QLayoutItem*)
Q_DECLARE_METATYPE(MyQLayoutItem*)

int QLayoutItem_QLayoutItem_QRegisterMetaType(){qRegisterMetaType<QLayoutItem*>(); return qRegisterMetaType<MyQLayoutItem*>();}

void* QLayoutItem_NewQLayoutItem(long long alignment)
{
	return new MyQLayoutItem(static_cast<Qt::AlignmentFlag>(alignment));
}

long long QLayoutItem_Alignment(void* ptr)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->alignment();
	} else {
		return static_cast<QLayoutItem*>(ptr)->alignment();
	}
}

long long QLayoutItem_ControlTypes(void* ptr)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->controlTypes();
	} else {
		return static_cast<QLayoutItem*>(ptr)->controlTypes();
	}
}

long long QLayoutItem_ControlTypesDefault(void* ptr)
{
	if (dynamic_cast<QWidgetItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QWidgetItem*>(ptr)->QWidgetItem::controlTypes();
	} else if (dynamic_cast<QSpacerItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QSpacerItem*>(ptr)->QSpacerItem::controlTypes();
	} else if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::controlTypes();
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFormLayout*>(ptr)->QFormLayout::controlTypes();
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::controlTypes();
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::controlTypes();
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::controlTypes();
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGridLayout*>(ptr)->QGridLayout::controlTypes();
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->QLayout::controlTypes();
	} else {
		return static_cast<QLayoutItem*>(ptr)->QLayoutItem::controlTypes();
	}
}

long long QLayoutItem_ExpandingDirections(void* ptr)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->expandingDirections();
	} else {
		return static_cast<QLayoutItem*>(ptr)->expandingDirections();
	}
}

void* QLayoutItem_Geometry(void* ptr)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QLayout*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRect tmpValue = static_cast<QLayoutItem*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

char QLayoutItem_HasHeightForWidth(void* ptr)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->hasHeightForWidth();
	} else {
		return static_cast<QLayoutItem*>(ptr)->hasHeightForWidth();
	}
}

char QLayoutItem_HasHeightForWidthDefault(void* ptr)
{
	if (dynamic_cast<QWidgetItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QWidgetItem*>(ptr)->QWidgetItem::hasHeightForWidth();
	} else if (dynamic_cast<QSpacerItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QSpacerItem*>(ptr)->QSpacerItem::hasHeightForWidth();
	} else if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::hasHeightForWidth();
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFormLayout*>(ptr)->QFormLayout::hasHeightForWidth();
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::hasHeightForWidth();
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::hasHeightForWidth();
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::hasHeightForWidth();
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGridLayout*>(ptr)->QGridLayout::hasHeightForWidth();
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->QLayout::hasHeightForWidth();
	} else {
		return static_cast<QLayoutItem*>(ptr)->QLayoutItem::hasHeightForWidth();
	}
}

int QLayoutItem_HeightForWidth(void* ptr, int vin)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->heightForWidth(vin);
	} else {
		return static_cast<QLayoutItem*>(ptr)->heightForWidth(vin);
	}
}

int QLayoutItem_HeightForWidthDefault(void* ptr, int vin)
{
	if (dynamic_cast<QWidgetItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QWidgetItem*>(ptr)->QWidgetItem::heightForWidth(vin);
	} else if (dynamic_cast<QSpacerItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QSpacerItem*>(ptr)->QSpacerItem::heightForWidth(vin);
	} else if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::heightForWidth(vin);
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFormLayout*>(ptr)->QFormLayout::heightForWidth(vin);
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::heightForWidth(vin);
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::heightForWidth(vin);
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::heightForWidth(vin);
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGridLayout*>(ptr)->QGridLayout::heightForWidth(vin);
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->QLayout::heightForWidth(vin);
	} else {
		return static_cast<QLayoutItem*>(ptr)->QLayoutItem::heightForWidth(vin);
	}
}

void QLayoutItem_Invalidate(void* ptr)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QLayout*>(ptr)->invalidate();
	} else {
		static_cast<QLayoutItem*>(ptr)->invalidate();
	}
}

void QLayoutItem_InvalidateDefault(void* ptr)
{
	if (dynamic_cast<QWidgetItem*>(static_cast<QLayoutItem*>(ptr))) {
		static_cast<QWidgetItem*>(ptr)->QWidgetItem::invalidate();
	} else if (dynamic_cast<QSpacerItem*>(static_cast<QLayoutItem*>(ptr))) {
		static_cast<QSpacerItem*>(ptr)->QSpacerItem::invalidate();
	} else if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedLayout*>(ptr)->QStackedLayout::invalidate();
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QFormLayout*>(ptr)->QFormLayout::invalidate();
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::invalidate();
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::invalidate();
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QBoxLayout*>(ptr)->QBoxLayout::invalidate();
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QGridLayout*>(ptr)->QGridLayout::invalidate();
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QLayout*>(ptr)->QLayout::invalidate();
	} else {
		static_cast<QLayoutItem*>(ptr)->QLayoutItem::invalidate();
	}
}

char QLayoutItem_IsEmpty(void* ptr)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->isEmpty();
	} else {
		return static_cast<QLayoutItem*>(ptr)->isEmpty();
	}
}

void* QLayoutItem_Layout(void* ptr)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->layout();
	} else {
		return static_cast<QLayoutItem*>(ptr)->layout();
	}
}

void* QLayoutItem_LayoutDefault(void* ptr)
{
	if (dynamic_cast<QWidgetItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QWidgetItem*>(ptr)->QWidgetItem::layout();
	} else if (dynamic_cast<QSpacerItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QSpacerItem*>(ptr)->QSpacerItem::layout();
	} else if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::layout();
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFormLayout*>(ptr)->QFormLayout::layout();
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::layout();
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::layout();
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::layout();
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGridLayout*>(ptr)->QGridLayout::layout();
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->QLayout::layout();
	} else {
		return static_cast<QLayoutItem*>(ptr)->QLayoutItem::layout();
	}
}

void* QLayoutItem_MaximumSize(void* ptr)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QLayout*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QLayoutItem*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

int QLayoutItem_MinimumHeightForWidth(void* ptr, int w)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->minimumHeightForWidth(w);
	} else {
		return static_cast<QLayoutItem*>(ptr)->minimumHeightForWidth(w);
	}
}

int QLayoutItem_MinimumHeightForWidthDefault(void* ptr, int w)
{
	if (dynamic_cast<QWidgetItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QWidgetItem*>(ptr)->QWidgetItem::minimumHeightForWidth(w);
	} else if (dynamic_cast<QSpacerItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QSpacerItem*>(ptr)->QSpacerItem::minimumHeightForWidth(w);
	} else if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::minimumHeightForWidth(w);
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFormLayout*>(ptr)->QFormLayout::minimumHeightForWidth(w);
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::minimumHeightForWidth(w);
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::minimumHeightForWidth(w);
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::minimumHeightForWidth(w);
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGridLayout*>(ptr)->QGridLayout::minimumHeightForWidth(w);
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->QLayout::minimumHeightForWidth(w);
	} else {
		return static_cast<QLayoutItem*>(ptr)->QLayoutItem::minimumHeightForWidth(w);
	}
}

void* QLayoutItem_MinimumSize(void* ptr)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QLayout*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QLayoutItem*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void QLayoutItem_SetAlignment(void* ptr, long long alignment)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QLayout*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(alignment));
	} else {
		static_cast<QLayoutItem*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(alignment));
	}
}

void QLayoutItem_SetGeometry(void* ptr, void* r)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		static_cast<QLayout*>(ptr)->setGeometry(*static_cast<QRect*>(r));
	} else {
		static_cast<QLayoutItem*>(ptr)->setGeometry(*static_cast<QRect*>(r));
	}
}

void* QLayoutItem_SizeHint(void* ptr)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QLayout*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QLayoutItem*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void* QLayoutItem_SpacerItem(void* ptr)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->spacerItem();
	} else {
		return static_cast<QLayoutItem*>(ptr)->spacerItem();
	}
}

void* QLayoutItem_SpacerItemDefault(void* ptr)
{
	if (dynamic_cast<QWidgetItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QWidgetItem*>(ptr)->QWidgetItem::spacerItem();
	} else if (dynamic_cast<QSpacerItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QSpacerItem*>(ptr)->QSpacerItem::spacerItem();
	} else if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::spacerItem();
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFormLayout*>(ptr)->QFormLayout::spacerItem();
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::spacerItem();
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::spacerItem();
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::spacerItem();
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGridLayout*>(ptr)->QGridLayout::spacerItem();
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->QLayout::spacerItem();
	} else {
		return static_cast<QLayoutItem*>(ptr)->QLayoutItem::spacerItem();
	}
}

void* QLayoutItem_Widget(void* ptr)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->widget();
	} else {
		return static_cast<QLayoutItem*>(ptr)->widget();
	}
}

void* QLayoutItem_WidgetDefault(void* ptr)
{
	if (dynamic_cast<QWidgetItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QWidgetItem*>(ptr)->QWidgetItem::widget();
	} else if (dynamic_cast<QSpacerItem*>(static_cast<QLayoutItem*>(ptr))) {
		return static_cast<QSpacerItem*>(ptr)->QSpacerItem::widget();
	} else if (dynamic_cast<QStackedLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::widget();
	} else if (dynamic_cast<QFormLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFormLayout*>(ptr)->QFormLayout::widget();
	} else if (dynamic_cast<QVBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::widget();
	} else if (dynamic_cast<QHBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::widget();
	} else if (dynamic_cast<QBoxLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QBoxLayout*>(ptr)->QBoxLayout::widget();
	} else if (dynamic_cast<QGridLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGridLayout*>(ptr)->QGridLayout::widget();
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLayout*>(ptr)->QLayout::widget();
	} else {
		return static_cast<QLayoutItem*>(ptr)->QLayoutItem::widget();
	}
}

void QLayoutItem_DestroyQLayoutItem(void* ptr)
{
	static_cast<QLayoutItem*>(ptr)->~QLayoutItem();
}

void QLayoutItem_DestroyQLayoutItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQLineEdit: public QLineEdit
{
public:
	MyQLineEdit(QWidget *parent = Q_NULLPTR) : QLineEdit(parent) {QLineEdit_QLineEdit_QRegisterMetaType();};
	MyQLineEdit(const QString &contents, QWidget *parent = Q_NULLPTR) : QLineEdit(contents, parent) {QLineEdit_QLineEdit_QRegisterMetaType();};
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void clear() { callbackQLineEdit_Clear(this); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void copy() const { callbackQLineEdit_Copy(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_CursorPositionChanged(int oldPos, int newPos) { callbackQLineEdit_CursorPositionChanged(this, oldPos, newPos); };
	void cut() { callbackQLineEdit_Cut(this); };
	void dragEnterEvent(QDragEnterEvent * e) { callbackQWidget_DragEnterEvent(this, e); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQWidget_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQWidget_DragMoveEvent(this, e); };
	void dropEvent(QDropEvent * e) { callbackQWidget_DropEvent(this, e); };
	void Signal_EditingFinished() { callbackQLineEdit_EditingFinished(this); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void focusInEvent(QFocusEvent * e) { callbackQWidget_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQWidget_FocusOutEvent(this, e); };
	void inputMethodEvent(QInputMethodEvent * e) { callbackQWidget_InputMethodEvent(this, e); };
	QVariant inputMethodQuery(Qt::InputMethodQuery property) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), property)); };
	void Signal_InputRejected() { callbackQLineEdit_InputRejected(this); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQWidget_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
	void paste() { callbackQLineEdit_Paste(this); };
	void redo() { callbackQLineEdit_Redo(this); };
	void Signal_ReturnPressed() { callbackQLineEdit_ReturnPressed(this); };
	void selectAll() { callbackQLineEdit_SelectAll(this); };
	void Signal_SelectionChanged() { callbackQLineEdit_SelectionChanged(this); };
	void setText(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQLineEdit_SetText(this, vqsPacked); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_TextChanged(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQLineEdit_TextChanged(this, textPacked); };
	void Signal_TextEdited(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQLineEdit_TextEdited(this, textPacked); };
	void undo() { callbackQLineEdit_Undo(this); };
	 ~MyQLineEdit() { callbackQLineEdit_DestroyQLineEdit(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QLineEdit*)
Q_DECLARE_METATYPE(MyQLineEdit*)

int QLineEdit_QLineEdit_QRegisterMetaType(){qRegisterMetaType<QLineEdit*>(); return qRegisterMetaType<MyQLineEdit*>();}

void* QLineEdit_NewQLineEdit(void* parent)
{
		return new MyQLineEdit(static_cast<QWidget*>(parent));
}

void* QLineEdit_NewQLineEdit2(struct QtWidgets_PackedString contents, void* parent)
{
		return new MyQLineEdit(QString::fromUtf8(contents.data, contents.len), static_cast<QWidget*>(parent));
}

void QLineEdit_AddAction(void* ptr, void* action, long long position)
{
	static_cast<QLineEdit*>(ptr)->addAction(static_cast<QAction*>(action), static_cast<QLineEdit::ActionPosition>(position));
}

void* QLineEdit_AddAction2(void* ptr, void* icon, long long position)
{
	return static_cast<QLineEdit*>(ptr)->addAction(*static_cast<QIcon*>(icon), static_cast<QLineEdit::ActionPosition>(position));
}

long long QLineEdit_Alignment(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->alignment();
}

void QLineEdit_Backspace(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->backspace();
}

void QLineEdit_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "clear");
}

void QLineEdit_ClearDefault(void* ptr)
{
		static_cast<QLineEdit*>(ptr)->QLineEdit::clear();
}

void* QLineEdit_Completer(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->completer();
}

void QLineEdit_Copy(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "copy");
}

void QLineEdit_CopyDefault(void* ptr)
{
		static_cast<QLineEdit*>(ptr)->QLineEdit::copy();
}

void* QLineEdit_CreateStandardContextMenu(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->createStandardContextMenu();
}

void QLineEdit_CursorBackward(void* ptr, char mark, int steps)
{
	static_cast<QLineEdit*>(ptr)->cursorBackward(mark != 0, steps);
}

void QLineEdit_CursorForward(void* ptr, char mark, int steps)
{
	static_cast<QLineEdit*>(ptr)->cursorForward(mark != 0, steps);
}

long long QLineEdit_CursorMoveStyle(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->cursorMoveStyle();
}

int QLineEdit_CursorPosition(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->cursorPosition();
}

int QLineEdit_CursorPositionAt(void* ptr, void* pos)
{
	return static_cast<QLineEdit*>(ptr)->cursorPositionAt(*static_cast<QPoint*>(pos));
}

void QLineEdit_ConnectCursorPositionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)(int, int)>(&QLineEdit::cursorPositionChanged), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)(int, int)>(&MyQLineEdit::Signal_CursorPositionChanged), static_cast<Qt::ConnectionType>(t));
}

void QLineEdit_DisconnectCursorPositionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)(int, int)>(&QLineEdit::cursorPositionChanged), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)(int, int)>(&MyQLineEdit::Signal_CursorPositionChanged));
}

void QLineEdit_CursorPositionChanged(void* ptr, int oldPos, int newPos)
{
	static_cast<QLineEdit*>(ptr)->cursorPositionChanged(oldPos, newPos);
}

void* QLineEdit_CursorRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QLineEdit*>(ptr)->cursorRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QLineEdit_CursorWordBackward(void* ptr, char mark)
{
	static_cast<QLineEdit*>(ptr)->cursorWordBackward(mark != 0);
}

void QLineEdit_CursorWordForward(void* ptr, char mark)
{
	static_cast<QLineEdit*>(ptr)->cursorWordForward(mark != 0);
}

void QLineEdit_Cut(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "cut");
}

void QLineEdit_CutDefault(void* ptr)
{
		static_cast<QLineEdit*>(ptr)->QLineEdit::cut();
}

void QLineEdit_Del(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->del();
}

void QLineEdit_Deselect(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->deselect();
}

struct QtWidgets_PackedString QLineEdit_DisplayText(void* ptr)
{
	return ({ QByteArray* t6ee01b = new QByteArray(static_cast<QLineEdit*>(ptr)->displayText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t6ee01b->prepend("WHITESPACE").constData()+10), t6ee01b->size()-10, t6ee01b }; });
}

char QLineEdit_DragEnabled(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->dragEnabled();
}

long long QLineEdit_EchoMode(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->echoMode();
}

void QLineEdit_ConnectEditingFinished(void* ptr, long long t)
{
	QObject::connect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)()>(&QLineEdit::editingFinished), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)()>(&MyQLineEdit::Signal_EditingFinished), static_cast<Qt::ConnectionType>(t));
}

void QLineEdit_DisconnectEditingFinished(void* ptr)
{
	QObject::disconnect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)()>(&QLineEdit::editingFinished), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)()>(&MyQLineEdit::Signal_EditingFinished));
}

void QLineEdit_EditingFinished(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->editingFinished();
}

void QLineEdit_End(void* ptr, char mark)
{
	static_cast<QLineEdit*>(ptr)->end(mark != 0);
}

void QLineEdit_GetTextMargins(void* ptr, int left, int top, int right, int bottom)
{
	static_cast<QLineEdit*>(ptr)->getTextMargins(&left, &top, &right, &bottom);
}

char QLineEdit_HasAcceptableInput(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->hasAcceptableInput();
}

char QLineEdit_HasFrame(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->hasFrame();
}

char QLineEdit_HasSelectedText(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->hasSelectedText();
}

void QLineEdit_Home(void* ptr, char mark)
{
	static_cast<QLineEdit*>(ptr)->home(mark != 0);
}

void QLineEdit_InitStyleOption(void* ptr, void* option)
{
	static_cast<QLineEdit*>(ptr)->initStyleOption(static_cast<QStyleOptionFrame*>(option));
}

struct QtWidgets_PackedString QLineEdit_InputMask(void* ptr)
{
	return ({ QByteArray* taabe0f = new QByteArray(static_cast<QLineEdit*>(ptr)->inputMask().toUtf8()); QtWidgets_PackedString { const_cast<char*>(taabe0f->prepend("WHITESPACE").constData()+10), taabe0f->size()-10, taabe0f }; });
}

void QLineEdit_ConnectInputRejected(void* ptr, long long t)
{
	QObject::connect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)()>(&QLineEdit::inputRejected), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)()>(&MyQLineEdit::Signal_InputRejected), static_cast<Qt::ConnectionType>(t));
}

void QLineEdit_DisconnectInputRejected(void* ptr)
{
	QObject::disconnect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)()>(&QLineEdit::inputRejected), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)()>(&MyQLineEdit::Signal_InputRejected));
}

void QLineEdit_InputRejected(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->inputRejected();
}

void QLineEdit_Insert(void* ptr, struct QtWidgets_PackedString newText)
{
	static_cast<QLineEdit*>(ptr)->insert(QString::fromUtf8(newText.data, newText.len));
}

char QLineEdit_IsClearButtonEnabled(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->isClearButtonEnabled();
}

char QLineEdit_IsModified(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->isModified();
}

char QLineEdit_IsReadOnly(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->isReadOnly();
}

char QLineEdit_IsRedoAvailable(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->isRedoAvailable();
}

char QLineEdit_IsUndoAvailable(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->isUndoAvailable();
}

int QLineEdit_MaxLength(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->maxLength();
}

void QLineEdit_Paste(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "paste");
}

void QLineEdit_PasteDefault(void* ptr)
{
		static_cast<QLineEdit*>(ptr)->QLineEdit::paste();
}

struct QtWidgets_PackedString QLineEdit_PlaceholderText(void* ptr)
{
	return ({ QByteArray* t749e76 = new QByteArray(static_cast<QLineEdit*>(ptr)->placeholderText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t749e76->prepend("WHITESPACE").constData()+10), t749e76->size()-10, t749e76 }; });
}

void QLineEdit_Redo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "redo");
}

void QLineEdit_RedoDefault(void* ptr)
{
		static_cast<QLineEdit*>(ptr)->QLineEdit::redo();
}

void QLineEdit_ConnectReturnPressed(void* ptr, long long t)
{
	QObject::connect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)()>(&QLineEdit::returnPressed), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)()>(&MyQLineEdit::Signal_ReturnPressed), static_cast<Qt::ConnectionType>(t));
}

void QLineEdit_DisconnectReturnPressed(void* ptr)
{
	QObject::disconnect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)()>(&QLineEdit::returnPressed), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)()>(&MyQLineEdit::Signal_ReturnPressed));
}

void QLineEdit_ReturnPressed(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->returnPressed();
}

void QLineEdit_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "selectAll");
}

void QLineEdit_SelectAllDefault(void* ptr)
{
		static_cast<QLineEdit*>(ptr)->QLineEdit::selectAll();
}

struct QtWidgets_PackedString QLineEdit_SelectedText(void* ptr)
{
	return ({ QByteArray* t1e6e00 = new QByteArray(static_cast<QLineEdit*>(ptr)->selectedText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t1e6e00->prepend("WHITESPACE").constData()+10), t1e6e00->size()-10, t1e6e00 }; });
}

void QLineEdit_ConnectSelectionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)()>(&QLineEdit::selectionChanged), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)()>(&MyQLineEdit::Signal_SelectionChanged), static_cast<Qt::ConnectionType>(t));
}

void QLineEdit_DisconnectSelectionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)()>(&QLineEdit::selectionChanged), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)()>(&MyQLineEdit::Signal_SelectionChanged));
}

void QLineEdit_SelectionChanged(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->selectionChanged();
}

int QLineEdit_SelectionEnd(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->selectionEnd();
}

int QLineEdit_SelectionLength(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->selectionLength();
}

int QLineEdit_SelectionStart(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->selectionStart();
}

void QLineEdit_SetAlignment(void* ptr, long long flag)
{
	static_cast<QLineEdit*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(flag));
}

void QLineEdit_SetClearButtonEnabled(void* ptr, char enable)
{
	static_cast<QLineEdit*>(ptr)->setClearButtonEnabled(enable != 0);
}

void QLineEdit_SetCompleter(void* ptr, void* c)
{
	static_cast<QLineEdit*>(ptr)->setCompleter(static_cast<QCompleter*>(c));
}

void QLineEdit_SetCursorMoveStyle(void* ptr, long long style)
{
	static_cast<QLineEdit*>(ptr)->setCursorMoveStyle(static_cast<Qt::CursorMoveStyle>(style));
}

void QLineEdit_SetCursorPosition(void* ptr, int vin)
{
	static_cast<QLineEdit*>(ptr)->setCursorPosition(vin);
}

void QLineEdit_SetDragEnabled(void* ptr, char b)
{
	static_cast<QLineEdit*>(ptr)->setDragEnabled(b != 0);
}

void QLineEdit_SetEchoMode(void* ptr, long long vql)
{
	static_cast<QLineEdit*>(ptr)->setEchoMode(static_cast<QLineEdit::EchoMode>(vql));
}

void QLineEdit_SetFrame(void* ptr, char vbo)
{
	static_cast<QLineEdit*>(ptr)->setFrame(vbo != 0);
}

void QLineEdit_SetInputMask(void* ptr, struct QtWidgets_PackedString inputMask)
{
	static_cast<QLineEdit*>(ptr)->setInputMask(QString::fromUtf8(inputMask.data, inputMask.len));
}

void QLineEdit_SetMaxLength(void* ptr, int vin)
{
	static_cast<QLineEdit*>(ptr)->setMaxLength(vin);
}

void QLineEdit_SetModified(void* ptr, char vbo)
{
	static_cast<QLineEdit*>(ptr)->setModified(vbo != 0);
}

void QLineEdit_SetPlaceholderText(void* ptr, struct QtWidgets_PackedString vqs)
{
	static_cast<QLineEdit*>(ptr)->setPlaceholderText(QString::fromUtf8(vqs.data, vqs.len));
}

void QLineEdit_SetReadOnly(void* ptr, char vbo)
{
	static_cast<QLineEdit*>(ptr)->setReadOnly(vbo != 0);
}

void QLineEdit_SetSelection(void* ptr, int start, int length)
{
	static_cast<QLineEdit*>(ptr)->setSelection(start, length);
}

void QLineEdit_SetText(void* ptr, struct QtWidgets_PackedString vqs)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setText", Q_ARG(const QString, QString::fromUtf8(vqs.data, vqs.len)));
}

void QLineEdit_SetTextDefault(void* ptr, struct QtWidgets_PackedString vqs)
{
		static_cast<QLineEdit*>(ptr)->QLineEdit::setText(QString::fromUtf8(vqs.data, vqs.len));
}

void QLineEdit_SetTextMargins(void* ptr, int left, int top, int right, int bottom)
{
	static_cast<QLineEdit*>(ptr)->setTextMargins(left, top, right, bottom);
}

void QLineEdit_SetTextMargins2(void* ptr, void* margins)
{
	static_cast<QLineEdit*>(ptr)->setTextMargins(*static_cast<QMargins*>(margins));
}

void QLineEdit_SetValidator(void* ptr, void* v)
{
	static_cast<QLineEdit*>(ptr)->setValidator(static_cast<QValidator*>(v));
}

struct QtWidgets_PackedString QLineEdit_Text(void* ptr)
{
	return ({ QByteArray* te2605d = new QByteArray(static_cast<QLineEdit*>(ptr)->text().toUtf8()); QtWidgets_PackedString { const_cast<char*>(te2605d->prepend("WHITESPACE").constData()+10), te2605d->size()-10, te2605d }; });
}

void QLineEdit_ConnectTextChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)(const QString &)>(&QLineEdit::textChanged), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)(const QString &)>(&MyQLineEdit::Signal_TextChanged), static_cast<Qt::ConnectionType>(t));
}

void QLineEdit_DisconnectTextChanged(void* ptr)
{
	QObject::disconnect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)(const QString &)>(&QLineEdit::textChanged), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)(const QString &)>(&MyQLineEdit::Signal_TextChanged));
}

void QLineEdit_TextChanged(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QLineEdit*>(ptr)->textChanged(QString::fromUtf8(text.data, text.len));
}

void QLineEdit_ConnectTextEdited(void* ptr, long long t)
{
	QObject::connect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)(const QString &)>(&QLineEdit::textEdited), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)(const QString &)>(&MyQLineEdit::Signal_TextEdited), static_cast<Qt::ConnectionType>(t));
}

void QLineEdit_DisconnectTextEdited(void* ptr)
{
	QObject::disconnect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)(const QString &)>(&QLineEdit::textEdited), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)(const QString &)>(&MyQLineEdit::Signal_TextEdited));
}

void QLineEdit_TextEdited(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QLineEdit*>(ptr)->textEdited(QString::fromUtf8(text.data, text.len));
}

void* QLineEdit_TextMargins(void* ptr)
{
	return ({ QMargins tmpValue = static_cast<QLineEdit*>(ptr)->textMargins(); new QMargins(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}

void QLineEdit_Undo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "undo");
}

void QLineEdit_UndoDefault(void* ptr)
{
		static_cast<QLineEdit*>(ptr)->QLineEdit::undo();
}

void* QLineEdit_Validator(void* ptr)
{
	return const_cast<QValidator*>(static_cast<QLineEdit*>(ptr)->validator());
}

void QLineEdit_DestroyQLineEdit(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->~QLineEdit();
}

void QLineEdit_DestroyQLineEditDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQListView: public QListView
{
public:
	MyQListView(QWidget *parent = Q_NULLPTR) : QListView(parent) {QListView_QListView_QRegisterMetaType();};
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQListView_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	void dataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQListView_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQWidget_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQWidget_DragMoveEvent(this, e); };
	void dropEvent(QDropEvent * e) { callbackQWidget_DropEvent(this, e); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	int horizontalOffset() const { return callbackQListView_HorizontalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QModelIndex indexAt(const QPoint & p) const { return *static_cast<QModelIndex*>(callbackQListView_IndexAt(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&p))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQListView_IsIndexHidden(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index)) != 0; };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQListView_MoveCursor(this, cursorAction, modifiers)); };
	void paintEvent(QPaintEvent * e) { callbackQWidget_PaintEvent(this, e); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQListView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQListView_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQListView_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	QList<QModelIndex> selectedIndexes() const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemView_SelectedIndexes(const_cast<void*>(static_cast<const void*>(this)))); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQListView_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQListView_SetSelection(this, const_cast<QRect*>(&rect), command); };
	void startDrag(Qt::DropActions supportedActions) { callbackQAbstractItemView_StartDrag(this, supportedActions); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void updateGeometries() { callbackQListView_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQListView_VerticalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQAbstractItemView_ViewOptions(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQListView_VisualRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQListView_VisualRegionForSelection(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&selection))); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	 ~MyQListView() { callbackQListView_DestroyQListView(this); };
	void Signal_Activated(const QModelIndex & index) { callbackQAbstractItemView_Activated(this, const_cast<QModelIndex*>(&index)); };
	void clearSelection() { callbackQAbstractItemView_ClearSelection(this); };
	void Signal_Clicked(const QModelIndex & index) { callbackQAbstractItemView_Clicked(this, const_cast<QModelIndex*>(&index)); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQAbstractItemView_CommitData(this, editor); };
	void Signal_DoubleClicked(const QModelIndex & index) { callbackQAbstractItemView_DoubleClicked(this, const_cast<QModelIndex*>(&index)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQAbstractItemView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQAbstractItemView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQAbstractItemView_EditorDestroyed(this, editor); };
	void Signal_Entered(const QModelIndex & index) { callbackQAbstractItemView_Entered(this, const_cast<QModelIndex*>(&index)); };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQWidget_EventFilter(this, object, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void Signal_IconSizeChanged(const QSize & size) { callbackQAbstractItemView_IconSizeChanged(this, const_cast<QSize*>(&size)); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { QByteArray* t3559d7 = new QByteArray(search.toUtf8()); QtWidgets_PackedString searchPacked = { const_cast<char*>(t3559d7->prepend("WHITESPACE").constData()+10), t3559d7->size()-10, t3559d7 };callbackQAbstractItemView_KeyboardSearch(this, searchPacked); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void Signal_Pressed(const QModelIndex & index) { callbackQAbstractItemView_Pressed(this, const_cast<QModelIndex*>(&index)); };
	void reset() { callbackQAbstractItemView_Reset(this); };
	void scrollToBottom() { callbackQAbstractItemView_ScrollToBottom(this); };
	void scrollToTop() { callbackQAbstractItemView_ScrollToTop(this); };
	void selectAll() { callbackQAbstractItemView_SelectAll(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQAbstractItemView_SelectionCommand(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQAbstractItemView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	void setModel(QAbstractItemModel * model) { callbackQAbstractItemView_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQAbstractItemView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQAbstractItemView_SetSelectionModel(this, selectionModel); };
	int sizeHintForColumn(int column) const { return callbackQAbstractItemView_SizeHintForColumn(const_cast<void*>(static_cast<const void*>(this)), column); };
	int sizeHintForRow(int row) const { return callbackQAbstractItemView_SizeHintForRow(const_cast<void*>(static_cast<const void*>(this)), row); };
	void update(const QModelIndex & index) { callbackQAbstractItemView_Update(this, const_cast<QModelIndex*>(&index)); };
	void Signal_ViewportEntered() { callbackQAbstractItemView_ViewportEntered(this); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QListView*)
Q_DECLARE_METATYPE(MyQListView*)

int QListView_QListView_QRegisterMetaType(){qRegisterMetaType<QListView*>(); return qRegisterMetaType<MyQListView*>();}

void* QListView_NewQListView(void* parent)
{
		return new MyQListView(static_cast<QWidget*>(parent));
}

int QListView_BatchSize(void* ptr)
{
	return static_cast<QListView*>(ptr)->batchSize();
}

void QListView_ClearPropertyFlags(void* ptr)
{
	static_cast<QListView*>(ptr)->clearPropertyFlags();
}

void QListView_CurrentChanged(void* ptr, void* current, void* previous)
{
	static_cast<QListView*>(ptr)->currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QListView_CurrentChangedDefault(void* ptr, void* current, void* previous)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	} else {
		static_cast<QListView*>(ptr)->QListView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	}
}

void QListView_DataChanged(void* ptr, void* topLeft, void* bottomRight, void* roles)
{
	static_cast<QListView*>(ptr)->dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
}

void QListView_DataChangedDefault(void* ptr, void* topLeft, void* bottomRight, void* roles)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	} else {
		static_cast<QListView*>(ptr)->QListView::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	}
}

long long QListView_Flow(void* ptr)
{
	return static_cast<QListView*>(ptr)->flow();
}

void* QListView_GridSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListView*>(ptr)->gridSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QListView_HorizontalOffset(void* ptr)
{
	return static_cast<QListView*>(ptr)->horizontalOffset();
}

int QListView_HorizontalOffsetDefault(void* ptr)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::horizontalOffset();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::horizontalOffset();
	} else {
		return static_cast<QListView*>(ptr)->QListView::horizontalOffset();
	}
}

void* QListView_IndexAt(void* ptr, void* p)
{
	return new QModelIndex(static_cast<QListView*>(ptr)->indexAt(*static_cast<QPoint*>(p)));
}

void* QListView_IndexAtDefault(void* ptr, void* p)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return new QModelIndex(static_cast<QUndoView*>(ptr)->QUndoView::indexAt(*static_cast<QPoint*>(p)));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return new QModelIndex(static_cast<QListWidget*>(ptr)->QListWidget::indexAt(*static_cast<QPoint*>(p)));
	} else {
		return new QModelIndex(static_cast<QListView*>(ptr)->QListView::indexAt(*static_cast<QPoint*>(p)));
	}
}

char QListView_IsIndexHidden(void* ptr, void* index)
{
	return static_cast<QListView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}

char QListView_IsIndexHiddenDefault(void* ptr, void* index)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::isIndexHidden(*static_cast<QModelIndex*>(index));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::isIndexHidden(*static_cast<QModelIndex*>(index));
	} else {
		return static_cast<QListView*>(ptr)->QListView::isIndexHidden(*static_cast<QModelIndex*>(index));
	}
}

char QListView_IsRowHidden(void* ptr, int row)
{
	return static_cast<QListView*>(ptr)->isRowHidden(row);
}

char QListView_IsSelectionRectVisible(void* ptr)
{
	return static_cast<QListView*>(ptr)->isSelectionRectVisible();
}

char QListView_IsWrapping(void* ptr)
{
	return static_cast<QListView*>(ptr)->isWrapping();
}

long long QListView_ItemAlignment(void* ptr)
{
	return static_cast<QListView*>(ptr)->itemAlignment();
}

long long QListView_LayoutMode(void* ptr)
{
	return static_cast<QListView*>(ptr)->layoutMode();
}

int QListView_ModelColumn(void* ptr)
{
	return static_cast<QListView*>(ptr)->modelColumn();
}

void* QListView_MoveCursor(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QListView*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void* QListView_MoveCursorDefault(void* ptr, long long cursorAction, long long modifiers)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return new QModelIndex(static_cast<QUndoView*>(ptr)->QUndoView::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return new QModelIndex(static_cast<QListWidget*>(ptr)->QListWidget::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
	} else {
		return new QModelIndex(static_cast<QListView*>(ptr)->QListView::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
	}
}

long long QListView_Movement(void* ptr)
{
	return static_cast<QListView*>(ptr)->movement();
}

void* QListView_RectForIndex(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QListView*>(ptr)->rectForIndex(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

long long QListView_ResizeMode(void* ptr)
{
	return static_cast<QListView*>(ptr)->resizeMode();
}

void QListView_RowsAboutToBeRemoved(void* ptr, void* parent, int start, int end)
{
	static_cast<QListView*>(ptr)->rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
}

void QListView_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	} else {
		static_cast<QListView*>(ptr)->QListView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	}
}

void QListView_RowsInserted(void* ptr, void* parent, int start, int end)
{
	static_cast<QListView*>(ptr)->rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
}

void QListView_RowsInsertedDefault(void* ptr, void* parent, int start, int end)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	} else {
		static_cast<QListView*>(ptr)->QListView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	}
}

void QListView_ScrollTo(void* ptr, void* index, long long hint)
{
	static_cast<QListView*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QListView_ScrollToDefault(void* ptr, void* index, long long hint)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
	} else {
		static_cast<QListView*>(ptr)->QListView::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
	}
}

void QListView_SelectionChanged(void* ptr, void* selected, void* deselected)
{
	static_cast<QListView*>(ptr)->selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

void QListView_SelectionChangedDefault(void* ptr, void* selected, void* deselected)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	} else {
		static_cast<QListView*>(ptr)->QListView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	}
}

void QListView_SetBatchSize(void* ptr, int batchSize)
{
	static_cast<QListView*>(ptr)->setBatchSize(batchSize);
}

void QListView_SetFlow(void* ptr, long long flow)
{
	static_cast<QListView*>(ptr)->setFlow(static_cast<QListView::Flow>(flow));
}

void QListView_SetGridSize(void* ptr, void* size)
{
	static_cast<QListView*>(ptr)->setGridSize(*static_cast<QSize*>(size));
}

void QListView_SetItemAlignment(void* ptr, long long alignment)
{
	static_cast<QListView*>(ptr)->setItemAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}

void QListView_SetLayoutMode(void* ptr, long long mode)
{
	static_cast<QListView*>(ptr)->setLayoutMode(static_cast<QListView::LayoutMode>(mode));
}

void QListView_SetModelColumn(void* ptr, int column)
{
	static_cast<QListView*>(ptr)->setModelColumn(column);
}

void QListView_SetMovement(void* ptr, long long movement)
{
	static_cast<QListView*>(ptr)->setMovement(static_cast<QListView::Movement>(movement));
}

void QListView_SetPositionForIndex(void* ptr, void* position, void* index)
{
	static_cast<QListView*>(ptr)->setPositionForIndex(*static_cast<QPoint*>(position), *static_cast<QModelIndex*>(index));
}

void QListView_SetResizeMode(void* ptr, long long mode)
{
	static_cast<QListView*>(ptr)->setResizeMode(static_cast<QListView::ResizeMode>(mode));
}

void QListView_SetRowHidden(void* ptr, int row, char hide)
{
	static_cast<QListView*>(ptr)->setRowHidden(row, hide != 0);
}

void QListView_SetSelection(void* ptr, void* rect, long long command)
{
	static_cast<QListView*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QListView_SetSelectionDefault(void* ptr, void* rect, long long command)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
	} else {
		static_cast<QListView*>(ptr)->QListView::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
	}
}

void QListView_SetSelectionRectVisible(void* ptr, char show)
{
	static_cast<QListView*>(ptr)->setSelectionRectVisible(show != 0);
}

void QListView_SetSpacing(void* ptr, int space)
{
	static_cast<QListView*>(ptr)->setSpacing(space);
}

void QListView_SetUniformItemSizes(void* ptr, char enable)
{
	static_cast<QListView*>(ptr)->setUniformItemSizes(enable != 0);
}

void QListView_SetViewMode(void* ptr, long long mode)
{
	static_cast<QListView*>(ptr)->setViewMode(static_cast<QListView::ViewMode>(mode));
}

void QListView_SetWordWrap(void* ptr, char on)
{
	static_cast<QListView*>(ptr)->setWordWrap(on != 0);
}

void QListView_SetWrapping(void* ptr, char enable)
{
	static_cast<QListView*>(ptr)->setWrapping(enable != 0);
}

int QListView_Spacing(void* ptr)
{
	return static_cast<QListView*>(ptr)->spacing();
}

char QListView_UniformItemSizes(void* ptr)
{
	return static_cast<QListView*>(ptr)->uniformItemSizes();
}

void QListView_UpdateGeometries(void* ptr)
{
	static_cast<QListView*>(ptr)->updateGeometries();
}

void QListView_UpdateGeometriesDefault(void* ptr)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::updateGeometries();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::updateGeometries();
	} else {
		static_cast<QListView*>(ptr)->QListView::updateGeometries();
	}
}

int QListView_VerticalOffset(void* ptr)
{
	return static_cast<QListView*>(ptr)->verticalOffset();
}

int QListView_VerticalOffsetDefault(void* ptr)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::verticalOffset();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::verticalOffset();
	} else {
		return static_cast<QListView*>(ptr)->QListView::verticalOffset();
	}
}

long long QListView_ViewMode(void* ptr)
{
	return static_cast<QListView*>(ptr)->viewMode();
}

void* QListView_VisualRect(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QListView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QListView_VisualRectDefault(void* ptr, void* index)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QUndoView*>(ptr)->QUndoView::visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QListWidget*>(ptr)->QListWidget::visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRect tmpValue = static_cast<QListView*>(ptr)->QListView::visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QListView_VisualRegionForSelection(void* ptr, void* selection)
{
	return new QRegion(static_cast<QListView*>(ptr)->visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void* QListView_VisualRegionForSelectionDefault(void* ptr, void* selection)
{
	if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return new QRegion(static_cast<QUndoView*>(ptr)->QUndoView::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return new QRegion(static_cast<QListWidget*>(ptr)->QListWidget::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
	} else {
		return new QRegion(static_cast<QListView*>(ptr)->QListView::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
	}
}

char QListView_WordWrap(void* ptr)
{
	return static_cast<QListView*>(ptr)->wordWrap();
}

void QListView_DestroyQListView(void* ptr)
{
	static_cast<QListView*>(ptr)->~QListView();
}

void QListView_DestroyQListViewDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QListView___indexesMoved_indexes_atList(void* ptr, int i)
{
	return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QListView___indexesMoved_indexes_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QModelIndex>();
}

class MyQListWidget: public QListWidget
{
public:
	MyQListWidget(QWidget *parent = Q_NULLPTR) : QListWidget(parent) {QListWidget_QListWidget_QRegisterMetaType();};
	void clear() { callbackQListWidget_Clear(this); };
	void Signal_CurrentItemChanged(QListWidgetItem * current, QListWidgetItem * previous) { callbackQListWidget_CurrentItemChanged(this, current, previous); };
	void Signal_CurrentRowChanged(int currentRow) { callbackQListWidget_CurrentRowChanged(this, currentRow); };
	void Signal_CurrentTextChanged(const QString & currentText) { QByteArray* t5a0ada = new QByteArray(currentText.toUtf8()); QtWidgets_PackedString currentTextPacked = { const_cast<char*>(t5a0ada->prepend("WHITESPACE").constData()+10), t5a0ada->size()-10, t5a0ada };callbackQListWidget_CurrentTextChanged(this, currentTextPacked); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	bool dropMimeData(int index, const QMimeData * data, Qt::DropAction action) { return callbackQListWidget_DropMimeData(this, index, const_cast<QMimeData*>(data), action) != 0; };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void Signal_ItemActivated(QListWidgetItem * item) { callbackQListWidget_ItemActivated(this, item); };
	void Signal_ItemChanged(QListWidgetItem * item) { callbackQListWidget_ItemChanged(this, item); };
	void Signal_ItemClicked(QListWidgetItem * item) { callbackQListWidget_ItemClicked(this, item); };
	void Signal_ItemDoubleClicked(QListWidgetItem * item) { callbackQListWidget_ItemDoubleClicked(this, item); };
	void Signal_ItemEntered(QListWidgetItem * item) { callbackQListWidget_ItemEntered(this, item); };
	void Signal_ItemPressed(QListWidgetItem * item) { callbackQListWidget_ItemPressed(this, item); };
	void Signal_ItemSelectionChanged() { callbackQListWidget_ItemSelectionChanged(this); };
	QMimeData * mimeData(const QList<QListWidgetItem *> items) const { return static_cast<QMimeData*>(callbackQListWidget_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QListWidgetItem *>* tmpValue7316c8 = new QList<QListWidgetItem *>(items); QtWidgets_PackedList { tmpValue7316c8, tmpValue7316c8->size() }; }))); };
	QStringList mimeTypes() const { return ({ QtWidgets_PackedString tempVal = callbackQListWidget_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	void scrollToItem(const QListWidgetItem * item, QAbstractItemView::ScrollHint hint) { callbackQListWidget_ScrollToItem(this, const_cast<QListWidgetItem*>(item), hint); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQAbstractItemView_SetSelectionModel(this, selectionModel); };
	Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQListWidget_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQListWidget() { callbackQListWidget_DestroyQListWidget(this); };
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQListView_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	void dataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQListView_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQWidget_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQWidget_DragMoveEvent(this, e); };
	int horizontalOffset() const { return callbackQListView_HorizontalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QModelIndex indexAt(const QPoint & p) const { return *static_cast<QModelIndex*>(callbackQListView_IndexAt(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&p))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQListView_IsIndexHidden(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index)) != 0; };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQListView_MoveCursor(this, cursorAction, modifiers)); };
	void paintEvent(QPaintEvent * e) { callbackQWidget_PaintEvent(this, e); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQListView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQListView_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQListView_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	QList<QModelIndex> selectedIndexes() const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemView_SelectedIndexes(const_cast<void*>(static_cast<const void*>(this)))); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQListView_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQListView_SetSelection(this, const_cast<QRect*>(&rect), command); };
	void startDrag(Qt::DropActions supportedActions) { callbackQAbstractItemView_StartDrag(this, supportedActions); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void updateGeometries() { callbackQListView_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQListView_VerticalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQAbstractItemView_ViewOptions(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQListView_VisualRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQListView_VisualRegionForSelection(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&selection))); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void Signal_Activated(const QModelIndex & index) { callbackQAbstractItemView_Activated(this, const_cast<QModelIndex*>(&index)); };
	void clearSelection() { callbackQAbstractItemView_ClearSelection(this); };
	void Signal_Clicked(const QModelIndex & index) { callbackQAbstractItemView_Clicked(this, const_cast<QModelIndex*>(&index)); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQAbstractItemView_CommitData(this, editor); };
	void Signal_DoubleClicked(const QModelIndex & index) { callbackQAbstractItemView_DoubleClicked(this, const_cast<QModelIndex*>(&index)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQAbstractItemView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQAbstractItemView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQAbstractItemView_EditorDestroyed(this, editor); };
	void Signal_Entered(const QModelIndex & index) { callbackQAbstractItemView_Entered(this, const_cast<QModelIndex*>(&index)); };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQWidget_EventFilter(this, object, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void Signal_IconSizeChanged(const QSize & size) { callbackQAbstractItemView_IconSizeChanged(this, const_cast<QSize*>(&size)); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { QByteArray* t3559d7 = new QByteArray(search.toUtf8()); QtWidgets_PackedString searchPacked = { const_cast<char*>(t3559d7->prepend("WHITESPACE").constData()+10), t3559d7->size()-10, t3559d7 };callbackQAbstractItemView_KeyboardSearch(this, searchPacked); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void Signal_Pressed(const QModelIndex & index) { callbackQAbstractItemView_Pressed(this, const_cast<QModelIndex*>(&index)); };
	void reset() { callbackQAbstractItemView_Reset(this); };
	void scrollToBottom() { callbackQAbstractItemView_ScrollToBottom(this); };
	void scrollToTop() { callbackQAbstractItemView_ScrollToTop(this); };
	void selectAll() { callbackQAbstractItemView_SelectAll(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQAbstractItemView_SelectionCommand(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQAbstractItemView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	void setModel(QAbstractItemModel * model) { callbackQAbstractItemView_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQAbstractItemView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	int sizeHintForColumn(int column) const { return callbackQAbstractItemView_SizeHintForColumn(const_cast<void*>(static_cast<const void*>(this)), column); };
	int sizeHintForRow(int row) const { return callbackQAbstractItemView_SizeHintForRow(const_cast<void*>(static_cast<const void*>(this)), row); };
	void update(const QModelIndex & index) { callbackQAbstractItemView_Update(this, const_cast<QModelIndex*>(&index)); };
	void Signal_ViewportEntered() { callbackQAbstractItemView_ViewportEntered(this); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QListWidget*)
Q_DECLARE_METATYPE(MyQListWidget*)

int QListWidget_QListWidget_QRegisterMetaType(){qRegisterMetaType<QListWidget*>(); return qRegisterMetaType<MyQListWidget*>();}

void* QListWidget_NewQListWidget(void* parent)
{
		return new MyQListWidget(static_cast<QWidget*>(parent));
}

void QListWidget_AddItem(void* ptr, struct QtWidgets_PackedString label)
{
	static_cast<QListWidget*>(ptr)->addItem(QString::fromUtf8(label.data, label.len));
}

void QListWidget_AddItem2(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->addItem(static_cast<QListWidgetItem*>(item));
}

void QListWidget_AddItems(void* ptr, struct QtWidgets_PackedString labels)
{
	static_cast<QListWidget*>(ptr)->addItems(QString::fromUtf8(labels.data, labels.len).split("¡¦!", QString::SkipEmptyParts));
}

void QListWidget_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "clear");
}

void QListWidget_ClearDefault(void* ptr)
{
		static_cast<QListWidget*>(ptr)->QListWidget::clear();
}

void QListWidget_ClosePersistentEditor(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->closePersistentEditor(static_cast<QListWidgetItem*>(item));
}

int QListWidget_Count(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->count();
}

void* QListWidget_CurrentItem(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->currentItem();
}

void QListWidget_ConnectCurrentItemChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *, QListWidgetItem *)>(&QListWidget::currentItemChanged), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *, QListWidgetItem *)>(&MyQListWidget::Signal_CurrentItemChanged), static_cast<Qt::ConnectionType>(t));
}

void QListWidget_DisconnectCurrentItemChanged(void* ptr)
{
	QObject::disconnect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *, QListWidgetItem *)>(&QListWidget::currentItemChanged), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *, QListWidgetItem *)>(&MyQListWidget::Signal_CurrentItemChanged));
}

void QListWidget_CurrentItemChanged(void* ptr, void* current, void* previous)
{
	static_cast<QListWidget*>(ptr)->currentItemChanged(static_cast<QListWidgetItem*>(current), static_cast<QListWidgetItem*>(previous));
}

int QListWidget_CurrentRow(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->currentRow();
}

void QListWidget_ConnectCurrentRowChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(int)>(&QListWidget::currentRowChanged), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(int)>(&MyQListWidget::Signal_CurrentRowChanged), static_cast<Qt::ConnectionType>(t));
}

void QListWidget_DisconnectCurrentRowChanged(void* ptr)
{
	QObject::disconnect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(int)>(&QListWidget::currentRowChanged), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(int)>(&MyQListWidget::Signal_CurrentRowChanged));
}

void QListWidget_CurrentRowChanged(void* ptr, int currentRow)
{
	static_cast<QListWidget*>(ptr)->currentRowChanged(currentRow);
}

void QListWidget_ConnectCurrentTextChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(const QString &)>(&QListWidget::currentTextChanged), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(const QString &)>(&MyQListWidget::Signal_CurrentTextChanged), static_cast<Qt::ConnectionType>(t));
}

void QListWidget_DisconnectCurrentTextChanged(void* ptr)
{
	QObject::disconnect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(const QString &)>(&QListWidget::currentTextChanged), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(const QString &)>(&MyQListWidget::Signal_CurrentTextChanged));
}

void QListWidget_CurrentTextChanged(void* ptr, struct QtWidgets_PackedString currentText)
{
	static_cast<QListWidget*>(ptr)->currentTextChanged(QString::fromUtf8(currentText.data, currentText.len));
}

char QListWidget_DropMimeData(void* ptr, int index, void* data, long long action)
{
	return static_cast<QListWidget*>(ptr)->dropMimeData(index, static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action));
}

char QListWidget_DropMimeDataDefault(void* ptr, int index, void* data, long long action)
{
		return static_cast<QListWidget*>(ptr)->QListWidget::dropMimeData(index, static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action));
}

void QListWidget_EditItem(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->editItem(static_cast<QListWidgetItem*>(item));
}

struct QtWidgets_PackedList QListWidget_FindItems(void* ptr, struct QtWidgets_PackedString text, long long flags)
{
	return ({ QList<QListWidgetItem *>* tmpValued07d9e = new QList<QListWidgetItem *>(static_cast<QListWidget*>(ptr)->findItems(QString::fromUtf8(text.data, text.len), static_cast<Qt::MatchFlag>(flags))); QtWidgets_PackedList { tmpValued07d9e, tmpValued07d9e->size() }; });
}

void* QListWidget_IndexFromItem(void* ptr, void* item)
{
	return new QModelIndex(static_cast<QListWidget*>(ptr)->indexFromItem(static_cast<QListWidgetItem*>(item)));
}

void QListWidget_InsertItem(void* ptr, int row, void* item)
{
	static_cast<QListWidget*>(ptr)->insertItem(row, static_cast<QListWidgetItem*>(item));
}

void QListWidget_InsertItem2(void* ptr, int row, struct QtWidgets_PackedString label)
{
	static_cast<QListWidget*>(ptr)->insertItem(row, QString::fromUtf8(label.data, label.len));
}

void QListWidget_InsertItems(void* ptr, int row, struct QtWidgets_PackedString labels)
{
	static_cast<QListWidget*>(ptr)->insertItems(row, QString::fromUtf8(labels.data, labels.len).split("¡¦!", QString::SkipEmptyParts));
}

char QListWidget_IsPersistentEditorOpen(void* ptr, void* item)
{
	return static_cast<QListWidget*>(ptr)->isPersistentEditorOpen(static_cast<QListWidgetItem*>(item));
}

char QListWidget_IsSortingEnabled(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->isSortingEnabled();
}

void* QListWidget_Item(void* ptr, int row)
{
	return static_cast<QListWidget*>(ptr)->item(row);
}

void QListWidget_ConnectItemActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *)>(&QListWidget::itemActivated), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *)>(&MyQListWidget::Signal_ItemActivated), static_cast<Qt::ConnectionType>(t));
}

void QListWidget_DisconnectItemActivated(void* ptr)
{
	QObject::disconnect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *)>(&QListWidget::itemActivated), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *)>(&MyQListWidget::Signal_ItemActivated));
}

void QListWidget_ItemActivated(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->itemActivated(static_cast<QListWidgetItem*>(item));
}

void* QListWidget_ItemAt(void* ptr, void* p)
{
	return static_cast<QListWidget*>(ptr)->itemAt(*static_cast<QPoint*>(p));
}

void* QListWidget_ItemAt2(void* ptr, int x, int y)
{
	return static_cast<QListWidget*>(ptr)->itemAt(x, y);
}

void QListWidget_ConnectItemChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *)>(&QListWidget::itemChanged), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *)>(&MyQListWidget::Signal_ItemChanged), static_cast<Qt::ConnectionType>(t));
}

void QListWidget_DisconnectItemChanged(void* ptr)
{
	QObject::disconnect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *)>(&QListWidget::itemChanged), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *)>(&MyQListWidget::Signal_ItemChanged));
}

void QListWidget_ItemChanged(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->itemChanged(static_cast<QListWidgetItem*>(item));
}

void QListWidget_ConnectItemClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *)>(&QListWidget::itemClicked), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *)>(&MyQListWidget::Signal_ItemClicked), static_cast<Qt::ConnectionType>(t));
}

void QListWidget_DisconnectItemClicked(void* ptr)
{
	QObject::disconnect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *)>(&QListWidget::itemClicked), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *)>(&MyQListWidget::Signal_ItemClicked));
}

void QListWidget_ItemClicked(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->itemClicked(static_cast<QListWidgetItem*>(item));
}

void QListWidget_ConnectItemDoubleClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *)>(&QListWidget::itemDoubleClicked), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *)>(&MyQListWidget::Signal_ItemDoubleClicked), static_cast<Qt::ConnectionType>(t));
}

void QListWidget_DisconnectItemDoubleClicked(void* ptr)
{
	QObject::disconnect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *)>(&QListWidget::itemDoubleClicked), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *)>(&MyQListWidget::Signal_ItemDoubleClicked));
}

void QListWidget_ItemDoubleClicked(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->itemDoubleClicked(static_cast<QListWidgetItem*>(item));
}

void QListWidget_ConnectItemEntered(void* ptr, long long t)
{
	QObject::connect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *)>(&QListWidget::itemEntered), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *)>(&MyQListWidget::Signal_ItemEntered), static_cast<Qt::ConnectionType>(t));
}

void QListWidget_DisconnectItemEntered(void* ptr)
{
	QObject::disconnect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *)>(&QListWidget::itemEntered), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *)>(&MyQListWidget::Signal_ItemEntered));
}

void QListWidget_ItemEntered(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->itemEntered(static_cast<QListWidgetItem*>(item));
}

void* QListWidget_ItemFromIndex(void* ptr, void* index)
{
	return static_cast<QListWidget*>(ptr)->itemFromIndex(*static_cast<QModelIndex*>(index));
}

void QListWidget_ConnectItemPressed(void* ptr, long long t)
{
	QObject::connect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *)>(&QListWidget::itemPressed), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *)>(&MyQListWidget::Signal_ItemPressed), static_cast<Qt::ConnectionType>(t));
}

void QListWidget_DisconnectItemPressed(void* ptr)
{
	QObject::disconnect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)(QListWidgetItem *)>(&QListWidget::itemPressed), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)(QListWidgetItem *)>(&MyQListWidget::Signal_ItemPressed));
}

void QListWidget_ItemPressed(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->itemPressed(static_cast<QListWidgetItem*>(item));
}

void QListWidget_ConnectItemSelectionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)()>(&QListWidget::itemSelectionChanged), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)()>(&MyQListWidget::Signal_ItemSelectionChanged), static_cast<Qt::ConnectionType>(t));
}

void QListWidget_DisconnectItemSelectionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)()>(&QListWidget::itemSelectionChanged), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)()>(&MyQListWidget::Signal_ItemSelectionChanged));
}

void QListWidget_ItemSelectionChanged(void* ptr)
{
	static_cast<QListWidget*>(ptr)->itemSelectionChanged();
}

void* QListWidget_ItemWidget(void* ptr, void* item)
{
	return static_cast<QListWidget*>(ptr)->itemWidget(static_cast<QListWidgetItem*>(item));
}

struct QtWidgets_PackedList QListWidget_Items(void* ptr, void* data)
{
	return ({ QList<QListWidgetItem *>* tmpValueb42ece = new QList<QListWidgetItem *>(static_cast<QListWidget*>(ptr)->items(static_cast<QMimeData*>(data))); QtWidgets_PackedList { tmpValueb42ece, tmpValueb42ece->size() }; });
}

void* QListWidget_MimeData(void* ptr, void* items)
{
	return static_cast<QListWidget*>(ptr)->mimeData(*static_cast<QList<QListWidgetItem *>*>(items));
}

void* QListWidget_MimeDataDefault(void* ptr, void* items)
{
		return static_cast<QListWidget*>(ptr)->QListWidget::mimeData(*static_cast<QList<QListWidgetItem *>*>(items));
}

struct QtWidgets_PackedString QListWidget_MimeTypes(void* ptr)
{
	return ({ QByteArray* t46fd45 = new QByteArray(static_cast<QListWidget*>(ptr)->mimeTypes().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t46fd45->prepend("WHITESPACE").constData()+10), t46fd45->size()-10, t46fd45 }; });
}

struct QtWidgets_PackedString QListWidget_MimeTypesDefault(void* ptr)
{
		return ({ QByteArray* tc474fd = new QByteArray(static_cast<QListWidget*>(ptr)->QListWidget::mimeTypes().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(tc474fd->prepend("WHITESPACE").constData()+10), tc474fd->size()-10, tc474fd }; });
}

void QListWidget_OpenPersistentEditor(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->openPersistentEditor(static_cast<QListWidgetItem*>(item));
}

void QListWidget_RemoveItemWidget(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->removeItemWidget(static_cast<QListWidgetItem*>(item));
}

int QListWidget_Row(void* ptr, void* item)
{
	return static_cast<QListWidget*>(ptr)->row(static_cast<QListWidgetItem*>(item));
}

void QListWidget_ScrollToItem(void* ptr, void* item, long long hint)
{
	qRegisterMetaType<QAbstractItemView::ScrollHint>();
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "scrollToItem", Q_ARG(const QListWidgetItem*, static_cast<QListWidgetItem*>(item)), Q_ARG(QAbstractItemView::ScrollHint, static_cast<QAbstractItemView::ScrollHint>(hint)));
}

void QListWidget_ScrollToItemDefault(void* ptr, void* item, long long hint)
{
		static_cast<QListWidget*>(ptr)->QListWidget::scrollToItem(static_cast<QListWidgetItem*>(item), static_cast<QAbstractItemView::ScrollHint>(hint));
}

struct QtWidgets_PackedList QListWidget_SelectedItems(void* ptr)
{
	return ({ QList<QListWidgetItem *>* tmpValue43d795 = new QList<QListWidgetItem *>(static_cast<QListWidget*>(ptr)->selectedItems()); QtWidgets_PackedList { tmpValue43d795, tmpValue43d795->size() }; });
}

void QListWidget_SetCurrentItem(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->setCurrentItem(static_cast<QListWidgetItem*>(item));
}

void QListWidget_SetCurrentItem2(void* ptr, void* item, long long command)
{
	static_cast<QListWidget*>(ptr)->setCurrentItem(static_cast<QListWidgetItem*>(item), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QListWidget_SetCurrentRow(void* ptr, int row)
{
	static_cast<QListWidget*>(ptr)->setCurrentRow(row);
}

void QListWidget_SetCurrentRow2(void* ptr, int row, long long command)
{
	static_cast<QListWidget*>(ptr)->setCurrentRow(row, static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QListWidget_SetItemWidget(void* ptr, void* item, void* widget)
{
		static_cast<QListWidget*>(ptr)->setItemWidget(static_cast<QListWidgetItem*>(item), static_cast<QWidget*>(widget));
}

void QListWidget_SetSortingEnabled(void* ptr, char enable)
{
	static_cast<QListWidget*>(ptr)->setSortingEnabled(enable != 0);
}

void QListWidget_SortItems(void* ptr, long long order)
{
	static_cast<QListWidget*>(ptr)->sortItems(static_cast<Qt::SortOrder>(order));
}

long long QListWidget_SupportedDropActions(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->supportedDropActions();
}

long long QListWidget_SupportedDropActionsDefault(void* ptr)
{
		return static_cast<QListWidget*>(ptr)->QListWidget::supportedDropActions();
}

void* QListWidget_TakeItem(void* ptr, int row)
{
	return static_cast<QListWidget*>(ptr)->takeItem(row);
}

void* QListWidget_VisualItemRect(void* ptr, void* item)
{
	return ({ QRect tmpValue = static_cast<QListWidget*>(ptr)->visualItemRect(static_cast<QListWidgetItem*>(item)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QListWidget_DestroyQListWidget(void* ptr)
{
	static_cast<QListWidget*>(ptr)->~QListWidget();
}

void QListWidget_DestroyQListWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QListWidget___findItems_atList(void* ptr, int i)
{
	return ({QListWidgetItem * tmp = static_cast<QList<QListWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QListWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QListWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QListWidget___findItems_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QListWidgetItem *>();
}

void* QListWidget___items_atList(void* ptr, int i)
{
	return ({QListWidgetItem * tmp = static_cast<QList<QListWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QListWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QListWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QListWidget___items_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QListWidgetItem *>();
}

void* QListWidget___mimeData_items_atList(void* ptr, int i)
{
	return ({QListWidgetItem * tmp = static_cast<QList<QListWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QListWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QListWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QListWidget___mimeData_items_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QListWidgetItem *>();
}

void* QListWidget___selectedItems_atList(void* ptr, int i)
{
	return ({QListWidgetItem * tmp = static_cast<QList<QListWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QListWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QListWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QListWidget___selectedItems_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QListWidgetItem *>();
}

class MyQListWidgetItem: public QListWidgetItem
{
public:
	MyQListWidgetItem(QListWidget *parent = Q_NULLPTR, int ty = Type) : QListWidgetItem(parent, ty) {QListWidgetItem_QListWidgetItem_QRegisterMetaType();};
	MyQListWidgetItem(const QString &text, QListWidget *parent = Q_NULLPTR, int ty = Type) : QListWidgetItem(text, parent, ty) {QListWidgetItem_QListWidgetItem_QRegisterMetaType();};
	MyQListWidgetItem(const QIcon &icon, const QString &text, QListWidget *parent = Q_NULLPTR, int ty = Type) : QListWidgetItem(icon, text, parent, ty) {QListWidgetItem_QListWidgetItem_QRegisterMetaType();};
	MyQListWidgetItem(const QListWidgetItem &other) : QListWidgetItem(other) {QListWidgetItem_QListWidgetItem_QRegisterMetaType();};
	QListWidgetItem * clone() const { return static_cast<QListWidgetItem*>(callbackQListWidgetItem_Clone(const_cast<void*>(static_cast<const void*>(this)))); };
	QVariant data(int role) const { return *static_cast<QVariant*>(callbackQListWidgetItem_Data(const_cast<void*>(static_cast<const void*>(this)), role)); };
	void read(QDataStream & in) { callbackQListWidgetItem_Read(this, static_cast<QDataStream*>(&in)); };
	void setData(int role, const QVariant & value) { callbackQListWidgetItem_SetData(this, role, const_cast<QVariant*>(&value)); };
	void write(QDataStream & out) const { callbackQListWidgetItem_Write(const_cast<void*>(static_cast<const void*>(this)), static_cast<QDataStream*>(&out)); };
	 ~MyQListWidgetItem() { callbackQListWidgetItem_DestroyQListWidgetItem(this); };
};

Q_DECLARE_METATYPE(QListWidgetItem*)
Q_DECLARE_METATYPE(MyQListWidgetItem*)

int QListWidgetItem_QListWidgetItem_QRegisterMetaType(){qRegisterMetaType<QListWidgetItem*>(); return qRegisterMetaType<MyQListWidgetItem*>();}

void* QListWidgetItem_NewQListWidgetItem(void* parent, int ty)
{
	return new MyQListWidgetItem(static_cast<QListWidget*>(parent), ty);
}

void* QListWidgetItem_NewQListWidgetItem2(struct QtWidgets_PackedString text, void* parent, int ty)
{
	return new MyQListWidgetItem(QString::fromUtf8(text.data, text.len), static_cast<QListWidget*>(parent), ty);
}

void* QListWidgetItem_NewQListWidgetItem3(void* icon, struct QtWidgets_PackedString text, void* parent, int ty)
{
	return new MyQListWidgetItem(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QListWidget*>(parent), ty);
}

void* QListWidgetItem_NewQListWidgetItem4(void* other)
{
	return new MyQListWidgetItem(*static_cast<QListWidgetItem*>(other));
}

void* QListWidgetItem_Background(void* ptr)
{
	return new QBrush(static_cast<QListWidgetItem*>(ptr)->background());
}

long long QListWidgetItem_CheckState(void* ptr)
{
	return static_cast<QListWidgetItem*>(ptr)->checkState();
}

void* QListWidgetItem_Clone(void* ptr)
{
	return static_cast<QListWidgetItem*>(ptr)->clone();
}

void* QListWidgetItem_CloneDefault(void* ptr)
{
		return static_cast<QListWidgetItem*>(ptr)->QListWidgetItem::clone();
}

void* QListWidgetItem_Data(void* ptr, int role)
{
	return new QVariant(static_cast<QListWidgetItem*>(ptr)->data(role));
}

void* QListWidgetItem_DataDefault(void* ptr, int role)
{
		return new QVariant(static_cast<QListWidgetItem*>(ptr)->QListWidgetItem::data(role));
}

long long QListWidgetItem_Flags(void* ptr)
{
	return static_cast<QListWidgetItem*>(ptr)->flags();
}

void* QListWidgetItem_Font(void* ptr)
{
	return new QFont(static_cast<QListWidgetItem*>(ptr)->font());
}

void* QListWidgetItem_Foreground(void* ptr)
{
	return new QBrush(static_cast<QListWidgetItem*>(ptr)->foreground());
}

void* QListWidgetItem_Icon(void* ptr)
{
	return new QIcon(static_cast<QListWidgetItem*>(ptr)->icon());
}

char QListWidgetItem_IsHidden(void* ptr)
{
	return static_cast<QListWidgetItem*>(ptr)->isHidden();
}

char QListWidgetItem_IsSelected(void* ptr)
{
	return static_cast<QListWidgetItem*>(ptr)->isSelected();
}

void* QListWidgetItem_ListWidget(void* ptr)
{
	return static_cast<QListWidgetItem*>(ptr)->listWidget();
}

void QListWidgetItem_Read(void* ptr, void* in)
{
	static_cast<QListWidgetItem*>(ptr)->read(*static_cast<QDataStream*>(in));
}

void QListWidgetItem_ReadDefault(void* ptr, void* in)
{
		static_cast<QListWidgetItem*>(ptr)->QListWidgetItem::read(*static_cast<QDataStream*>(in));
}

void QListWidgetItem_SetBackground(void* ptr, void* brush)
{
	static_cast<QListWidgetItem*>(ptr)->setBackground(*static_cast<QBrush*>(brush));
}

void QListWidgetItem_SetCheckState(void* ptr, long long state)
{
	static_cast<QListWidgetItem*>(ptr)->setCheckState(static_cast<Qt::CheckState>(state));
}

void QListWidgetItem_SetData(void* ptr, int role, void* value)
{
	static_cast<QListWidgetItem*>(ptr)->setData(role, *static_cast<QVariant*>(value));
}

void QListWidgetItem_SetDataDefault(void* ptr, int role, void* value)
{
		static_cast<QListWidgetItem*>(ptr)->QListWidgetItem::setData(role, *static_cast<QVariant*>(value));
}

void QListWidgetItem_SetFlags(void* ptr, long long flags)
{
	static_cast<QListWidgetItem*>(ptr)->setFlags(static_cast<Qt::ItemFlag>(flags));
}

void QListWidgetItem_SetFont(void* ptr, void* font)
{
	static_cast<QListWidgetItem*>(ptr)->setFont(*static_cast<QFont*>(font));
}

void QListWidgetItem_SetForeground(void* ptr, void* brush)
{
	static_cast<QListWidgetItem*>(ptr)->setForeground(*static_cast<QBrush*>(brush));
}

void QListWidgetItem_SetHidden(void* ptr, char hide)
{
	static_cast<QListWidgetItem*>(ptr)->setHidden(hide != 0);
}

void QListWidgetItem_SetIcon(void* ptr, void* icon)
{
	static_cast<QListWidgetItem*>(ptr)->setIcon(*static_cast<QIcon*>(icon));
}

void QListWidgetItem_SetSelected(void* ptr, char sele)
{
	static_cast<QListWidgetItem*>(ptr)->setSelected(sele != 0);
}

void QListWidgetItem_SetSizeHint(void* ptr, void* size)
{
	static_cast<QListWidgetItem*>(ptr)->setSizeHint(*static_cast<QSize*>(size));
}

void QListWidgetItem_SetStatusTip(void* ptr, struct QtWidgets_PackedString statusTip)
{
	static_cast<QListWidgetItem*>(ptr)->setStatusTip(QString::fromUtf8(statusTip.data, statusTip.len));
}

void QListWidgetItem_SetText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QListWidgetItem*>(ptr)->setText(QString::fromUtf8(text.data, text.len));
}

void QListWidgetItem_SetTextAlignment(void* ptr, int alignment)
{
	static_cast<QListWidgetItem*>(ptr)->setTextAlignment(alignment);
}

void QListWidgetItem_SetToolTip(void* ptr, struct QtWidgets_PackedString toolTip)
{
	static_cast<QListWidgetItem*>(ptr)->setToolTip(QString::fromUtf8(toolTip.data, toolTip.len));
}

void QListWidgetItem_SetWhatsThis(void* ptr, struct QtWidgets_PackedString whatsThis)
{
	static_cast<QListWidgetItem*>(ptr)->setWhatsThis(QString::fromUtf8(whatsThis.data, whatsThis.len));
}

void* QListWidgetItem_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListWidgetItem*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

struct QtWidgets_PackedString QListWidgetItem_StatusTip(void* ptr)
{
	return ({ QByteArray* t97b7ce = new QByteArray(static_cast<QListWidgetItem*>(ptr)->statusTip().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t97b7ce->prepend("WHITESPACE").constData()+10), t97b7ce->size()-10, t97b7ce }; });
}

struct QtWidgets_PackedString QListWidgetItem_Text(void* ptr)
{
	return ({ QByteArray* t3d0f8a = new QByteArray(static_cast<QListWidgetItem*>(ptr)->text().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t3d0f8a->prepend("WHITESPACE").constData()+10), t3d0f8a->size()-10, t3d0f8a }; });
}

int QListWidgetItem_TextAlignment(void* ptr)
{
	return static_cast<QListWidgetItem*>(ptr)->textAlignment();
}

struct QtWidgets_PackedString QListWidgetItem_ToolTip(void* ptr)
{
	return ({ QByteArray* tc8991e = new QByteArray(static_cast<QListWidgetItem*>(ptr)->toolTip().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tc8991e->prepend("WHITESPACE").constData()+10), tc8991e->size()-10, tc8991e }; });
}

int QListWidgetItem_Type(void* ptr)
{
	return static_cast<QListWidgetItem*>(ptr)->type();
}

struct QtWidgets_PackedString QListWidgetItem_WhatsThis(void* ptr)
{
	return ({ QByteArray* tf613a8 = new QByteArray(static_cast<QListWidgetItem*>(ptr)->whatsThis().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tf613a8->prepend("WHITESPACE").constData()+10), tf613a8->size()-10, tf613a8 }; });
}

void QListWidgetItem_Write(void* ptr, void* out)
{
	static_cast<QListWidgetItem*>(ptr)->write(*static_cast<QDataStream*>(out));
}

void QListWidgetItem_WriteDefault(void* ptr, void* out)
{
		static_cast<QListWidgetItem*>(ptr)->QListWidgetItem::write(*static_cast<QDataStream*>(out));
}

void QListWidgetItem_DestroyQListWidgetItem(void* ptr)
{
	static_cast<QListWidgetItem*>(ptr)->~QListWidgetItem();
}

void QListWidgetItem_DestroyQListWidgetItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QListWidgetItem___dummy_atList(void* ptr, int i)
{
	return ({void * tmp = static_cast<QVector<void *>*>(ptr)->at(i); if (i == static_cast<QVector<void *>*>(ptr)->size()-1) { static_cast<QVector<void *>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}

void QListWidgetItem___dummy_setList(void* ptr, void* i)
{
	static_cast<QVector<void *>*>(ptr)->append(i);
}

void* QListWidgetItem___dummy_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<void *>();
}

void* QListWidgetItem___setDummy__atList(void* ptr, int i)
{
	return ({void * tmp = static_cast<QVector<void *>*>(ptr)->at(i); if (i == static_cast<QVector<void *>*>(ptr)->size()-1) { static_cast<QVector<void *>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}

void QListWidgetItem___setDummy__setList(void* ptr, void* i)
{
	static_cast<QVector<void *>*>(ptr)->append(i);
}

void* QListWidgetItem___setDummy__newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<void *>();
}

class MyQMainWindow: public QMainWindow
{
public:
	MyQMainWindow(QWidget *parent = Q_NULLPTR, Qt::WindowFlags flags = Qt::WindowFlags()) : QMainWindow(parent, flags) {QMainWindow_QMainWindow_QRegisterMetaType();};
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	QMenu * createPopupMenu() { return static_cast<QMenu*>(callbackQMainWindow_CreatePopupMenu(this)); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void Signal_IconSizeChanged(const QSize & iconSize) { callbackQMainWindow_IconSizeChanged(this, const_cast<QSize*>(&iconSize)); };
	void setAnimated(bool enabled) { callbackQMainWindow_SetAnimated(this, enabled); };
	void setDockNestingEnabled(bool enabled) { callbackQMainWindow_SetDockNestingEnabled(this, enabled); };
	void setUnifiedTitleAndToolBarOnMac(bool set) { callbackQMainWindow_SetUnifiedTitleAndToolBarOnMac(this, set); };
	void Signal_TabifiedDockWidgetActivated(QDockWidget * dockWidget) { callbackQMainWindow_TabifiedDockWidgetActivated(this, dockWidget); };
	void Signal_ToolButtonStyleChanged(Qt::ToolButtonStyle toolButtonStyle) { callbackQMainWindow_ToolButtonStyleChanged(this, toolButtonStyle); };
	 ~MyQMainWindow() { callbackQMainWindow_DestroyQMainWindow(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMainWindow*)
Q_DECLARE_METATYPE(MyQMainWindow*)

int QMainWindow_QMainWindow_QRegisterMetaType(){qRegisterMetaType<QMainWindow*>(); return qRegisterMetaType<MyQMainWindow*>();}

void* QMainWindow_NewQMainWindow(void* parent, long long flags)
{
		return new MyQMainWindow(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}

void QMainWindow_AddDockWidget(void* ptr, long long area, void* dockwidget)
{
	static_cast<QMainWindow*>(ptr)->addDockWidget(static_cast<Qt::DockWidgetArea>(area), static_cast<QDockWidget*>(dockwidget));
}

void QMainWindow_AddDockWidget2(void* ptr, long long area, void* dockwidget, long long orientation)
{
	static_cast<QMainWindow*>(ptr)->addDockWidget(static_cast<Qt::DockWidgetArea>(area), static_cast<QDockWidget*>(dockwidget), static_cast<Qt::Orientation>(orientation));
}

void QMainWindow_AddToolBar(void* ptr, long long area, void* toolbar)
{
	static_cast<QMainWindow*>(ptr)->addToolBar(static_cast<Qt::ToolBarArea>(area), static_cast<QToolBar*>(toolbar));
}

void QMainWindow_AddToolBar2(void* ptr, void* toolbar)
{
	static_cast<QMainWindow*>(ptr)->addToolBar(static_cast<QToolBar*>(toolbar));
}

void* QMainWindow_AddToolBar3(void* ptr, struct QtWidgets_PackedString title)
{
	return static_cast<QMainWindow*>(ptr)->addToolBar(QString::fromUtf8(title.data, title.len));
}

void QMainWindow_AddToolBarBreak(void* ptr, long long area)
{
	static_cast<QMainWindow*>(ptr)->addToolBarBreak(static_cast<Qt::ToolBarArea>(area));
}

void* QMainWindow_CentralWidget(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->centralWidget();
}

long long QMainWindow_Corner(void* ptr, long long corner)
{
	return static_cast<QMainWindow*>(ptr)->corner(static_cast<Qt::Corner>(corner));
}

void* QMainWindow_CreatePopupMenu(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->createPopupMenu();
}

void* QMainWindow_CreatePopupMenuDefault(void* ptr)
{
		return static_cast<QMainWindow*>(ptr)->QMainWindow::createPopupMenu();
}

long long QMainWindow_DockOptions(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->dockOptions();
}

long long QMainWindow_DockWidgetArea(void* ptr, void* dockwidget)
{
	return static_cast<QMainWindow*>(ptr)->dockWidgetArea(static_cast<QDockWidget*>(dockwidget));
}

char QMainWindow_DocumentMode(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->documentMode();
}

void* QMainWindow_IconSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMainWindow*>(ptr)->iconSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMainWindow_ConnectIconSizeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QMainWindow*>(ptr), static_cast<void (QMainWindow::*)(const QSize &)>(&QMainWindow::iconSizeChanged), static_cast<MyQMainWindow*>(ptr), static_cast<void (MyQMainWindow::*)(const QSize &)>(&MyQMainWindow::Signal_IconSizeChanged), static_cast<Qt::ConnectionType>(t));
}

void QMainWindow_DisconnectIconSizeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMainWindow*>(ptr), static_cast<void (QMainWindow::*)(const QSize &)>(&QMainWindow::iconSizeChanged), static_cast<MyQMainWindow*>(ptr), static_cast<void (MyQMainWindow::*)(const QSize &)>(&MyQMainWindow::Signal_IconSizeChanged));
}

void QMainWindow_IconSizeChanged(void* ptr, void* iconSize)
{
	static_cast<QMainWindow*>(ptr)->iconSizeChanged(*static_cast<QSize*>(iconSize));
}

void QMainWindow_InsertToolBar(void* ptr, void* before, void* toolbar)
{
	static_cast<QMainWindow*>(ptr)->insertToolBar(static_cast<QToolBar*>(before), static_cast<QToolBar*>(toolbar));
}

void QMainWindow_InsertToolBarBreak(void* ptr, void* before)
{
	static_cast<QMainWindow*>(ptr)->insertToolBarBreak(static_cast<QToolBar*>(before));
}

char QMainWindow_IsAnimated(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->isAnimated();
}

char QMainWindow_IsDockNestingEnabled(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->isDockNestingEnabled();
}

void* QMainWindow_MenuBar(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->menuBar();
}

void* QMainWindow_MenuWidget(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->menuWidget();
}

void QMainWindow_RemoveDockWidget(void* ptr, void* dockwidget)
{
	static_cast<QMainWindow*>(ptr)->removeDockWidget(static_cast<QDockWidget*>(dockwidget));
}

void QMainWindow_RemoveToolBar(void* ptr, void* toolbar)
{
	static_cast<QMainWindow*>(ptr)->removeToolBar(static_cast<QToolBar*>(toolbar));
}

void QMainWindow_RemoveToolBarBreak(void* ptr, void* before)
{
	static_cast<QMainWindow*>(ptr)->removeToolBarBreak(static_cast<QToolBar*>(before));
}

void QMainWindow_ResizeDocks(void* ptr, void* docks, void* sizes, long long orientation)
{
	static_cast<QMainWindow*>(ptr)->resizeDocks(*static_cast<QList<QDockWidget *>*>(docks), *static_cast<QList<int>*>(sizes), static_cast<Qt::Orientation>(orientation));
}

char QMainWindow_RestoreDockWidget(void* ptr, void* dockwidget)
{
	return static_cast<QMainWindow*>(ptr)->restoreDockWidget(static_cast<QDockWidget*>(dockwidget));
}

char QMainWindow_RestoreState(void* ptr, void* state, int version)
{
	return static_cast<QMainWindow*>(ptr)->restoreState(*static_cast<QByteArray*>(state), version);
}

void* QMainWindow_SaveState(void* ptr, int version)
{
	return new QByteArray(static_cast<QMainWindow*>(ptr)->saveState(version));
}

void QMainWindow_SetAnimated(void* ptr, char enabled)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setAnimated", Q_ARG(bool, enabled != 0));
}

void QMainWindow_SetAnimatedDefault(void* ptr, char enabled)
{
		static_cast<QMainWindow*>(ptr)->QMainWindow::setAnimated(enabled != 0);
}

void QMainWindow_SetCentralWidget(void* ptr, void* widget)
{
		static_cast<QMainWindow*>(ptr)->setCentralWidget(static_cast<QWidget*>(widget));
}

void QMainWindow_SetCorner(void* ptr, long long corner, long long area)
{
	static_cast<QMainWindow*>(ptr)->setCorner(static_cast<Qt::Corner>(corner), static_cast<Qt::DockWidgetArea>(area));
}

void QMainWindow_SetDockNestingEnabled(void* ptr, char enabled)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setDockNestingEnabled", Q_ARG(bool, enabled != 0));
}

void QMainWindow_SetDockNestingEnabledDefault(void* ptr, char enabled)
{
		static_cast<QMainWindow*>(ptr)->QMainWindow::setDockNestingEnabled(enabled != 0);
}

void QMainWindow_SetDockOptions(void* ptr, long long options)
{
	static_cast<QMainWindow*>(ptr)->setDockOptions(static_cast<QMainWindow::DockOption>(options));
}

void QMainWindow_SetDocumentMode(void* ptr, char enabled)
{
	static_cast<QMainWindow*>(ptr)->setDocumentMode(enabled != 0);
}

void QMainWindow_SetIconSize(void* ptr, void* iconSize)
{
	static_cast<QMainWindow*>(ptr)->setIconSize(*static_cast<QSize*>(iconSize));
}

void QMainWindow_SetMenuBar(void* ptr, void* menuBar)
{
	static_cast<QMainWindow*>(ptr)->setMenuBar(static_cast<QMenuBar*>(menuBar));
}

void QMainWindow_SetMenuWidget(void* ptr, void* menuBar)
{
		static_cast<QMainWindow*>(ptr)->setMenuWidget(static_cast<QWidget*>(menuBar));
}

void QMainWindow_SetStatusBar(void* ptr, void* statusbar)
{
	static_cast<QMainWindow*>(ptr)->setStatusBar(static_cast<QStatusBar*>(statusbar));
}

void QMainWindow_SetTabPosition(void* ptr, long long areas, long long tabPosition)
{
	static_cast<QMainWindow*>(ptr)->setTabPosition(static_cast<Qt::DockWidgetArea>(areas), static_cast<QTabWidget::TabPosition>(tabPosition));
}

void QMainWindow_SetTabShape(void* ptr, long long tabShape)
{
	static_cast<QMainWindow*>(ptr)->setTabShape(static_cast<QTabWidget::TabShape>(tabShape));
}

void QMainWindow_SetToolButtonStyle(void* ptr, long long toolButtonStyle)
{
	static_cast<QMainWindow*>(ptr)->setToolButtonStyle(static_cast<Qt::ToolButtonStyle>(toolButtonStyle));
}

void QMainWindow_SetUnifiedTitleAndToolBarOnMac(void* ptr, char set)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setUnifiedTitleAndToolBarOnMac", Q_ARG(bool, set != 0));
}

void QMainWindow_SetUnifiedTitleAndToolBarOnMacDefault(void* ptr, char set)
{
		static_cast<QMainWindow*>(ptr)->QMainWindow::setUnifiedTitleAndToolBarOnMac(set != 0);
}

void QMainWindow_SplitDockWidget(void* ptr, void* first, void* second, long long orientation)
{
	static_cast<QMainWindow*>(ptr)->splitDockWidget(static_cast<QDockWidget*>(first), static_cast<QDockWidget*>(second), static_cast<Qt::Orientation>(orientation));
}

void* QMainWindow_StatusBar(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->statusBar();
}

long long QMainWindow_TabPosition(void* ptr, long long area)
{
	return static_cast<QMainWindow*>(ptr)->tabPosition(static_cast<Qt::DockWidgetArea>(area));
}

long long QMainWindow_TabShape(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->tabShape();
}

void QMainWindow_ConnectTabifiedDockWidgetActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QMainWindow*>(ptr), static_cast<void (QMainWindow::*)(QDockWidget *)>(&QMainWindow::tabifiedDockWidgetActivated), static_cast<MyQMainWindow*>(ptr), static_cast<void (MyQMainWindow::*)(QDockWidget *)>(&MyQMainWindow::Signal_TabifiedDockWidgetActivated), static_cast<Qt::ConnectionType>(t));
}

void QMainWindow_DisconnectTabifiedDockWidgetActivated(void* ptr)
{
	QObject::disconnect(static_cast<QMainWindow*>(ptr), static_cast<void (QMainWindow::*)(QDockWidget *)>(&QMainWindow::tabifiedDockWidgetActivated), static_cast<MyQMainWindow*>(ptr), static_cast<void (MyQMainWindow::*)(QDockWidget *)>(&MyQMainWindow::Signal_TabifiedDockWidgetActivated));
}

void QMainWindow_TabifiedDockWidgetActivated(void* ptr, void* dockWidget)
{
	static_cast<QMainWindow*>(ptr)->tabifiedDockWidgetActivated(static_cast<QDockWidget*>(dockWidget));
}

struct QtWidgets_PackedList QMainWindow_TabifiedDockWidgets(void* ptr, void* dockwidget)
{
	return ({ QList<QDockWidget *>* tmpValueb01abb = new QList<QDockWidget *>(static_cast<QMainWindow*>(ptr)->tabifiedDockWidgets(static_cast<QDockWidget*>(dockwidget))); QtWidgets_PackedList { tmpValueb01abb, tmpValueb01abb->size() }; });
}

void QMainWindow_TabifyDockWidget(void* ptr, void* first, void* second)
{
	static_cast<QMainWindow*>(ptr)->tabifyDockWidget(static_cast<QDockWidget*>(first), static_cast<QDockWidget*>(second));
}

void* QMainWindow_TakeCentralWidget(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->takeCentralWidget();
}

long long QMainWindow_ToolBarArea(void* ptr, void* toolbar)
{
	return static_cast<QMainWindow*>(ptr)->toolBarArea(static_cast<QToolBar*>(toolbar));
}

char QMainWindow_ToolBarBreak(void* ptr, void* toolbar)
{
	return static_cast<QMainWindow*>(ptr)->toolBarBreak(static_cast<QToolBar*>(toolbar));
}

long long QMainWindow_ToolButtonStyle(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->toolButtonStyle();
}

void QMainWindow_ConnectToolButtonStyleChanged(void* ptr, long long t)
{
	qRegisterMetaType<Qt::ToolButtonStyle>();
	QObject::connect(static_cast<QMainWindow*>(ptr), static_cast<void (QMainWindow::*)(Qt::ToolButtonStyle)>(&QMainWindow::toolButtonStyleChanged), static_cast<MyQMainWindow*>(ptr), static_cast<void (MyQMainWindow::*)(Qt::ToolButtonStyle)>(&MyQMainWindow::Signal_ToolButtonStyleChanged), static_cast<Qt::ConnectionType>(t));
}

void QMainWindow_DisconnectToolButtonStyleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMainWindow*>(ptr), static_cast<void (QMainWindow::*)(Qt::ToolButtonStyle)>(&QMainWindow::toolButtonStyleChanged), static_cast<MyQMainWindow*>(ptr), static_cast<void (MyQMainWindow::*)(Qt::ToolButtonStyle)>(&MyQMainWindow::Signal_ToolButtonStyleChanged));
}

void QMainWindow_ToolButtonStyleChanged(void* ptr, long long toolButtonStyle)
{
	static_cast<QMainWindow*>(ptr)->toolButtonStyleChanged(static_cast<Qt::ToolButtonStyle>(toolButtonStyle));
}

char QMainWindow_UnifiedTitleAndToolBarOnMac(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->unifiedTitleAndToolBarOnMac();
}

void QMainWindow_DestroyQMainWindow(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->~QMainWindow();
}

void QMainWindow_DestroyQMainWindowDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QMainWindow___resizeDocks_docks_atList(void* ptr, int i)
{
	return ({QDockWidget * tmp = static_cast<QList<QDockWidget *>*>(ptr)->at(i); if (i == static_cast<QList<QDockWidget *>*>(ptr)->size()-1) { static_cast<QList<QDockWidget *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QMainWindow___resizeDocks_docks_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QDockWidget *>();
}

int QMainWindow___resizeDocks_sizes_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

void* QMainWindow___tabifiedDockWidgets_atList(void* ptr, int i)
{
	return ({QDockWidget * tmp = static_cast<QList<QDockWidget *>*>(ptr)->at(i); if (i == static_cast<QList<QDockWidget *>*>(ptr)->size()-1) { static_cast<QList<QDockWidget *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QMainWindow___tabifiedDockWidgets_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QDockWidget *>();
}

class MyQMdiArea: public QMdiArea
{
public:
	MyQMdiArea(QWidget *parent = Q_NULLPTR) : QMdiArea(parent) {QMdiArea_QMdiArea_QRegisterMetaType();};
	void activateNextSubWindow() { callbackQMdiArea_ActivateNextSubWindow(this); };
	void activatePreviousSubWindow() { callbackQMdiArea_ActivatePreviousSubWindow(this); };
	void cascadeSubWindows() { callbackQMdiArea_CascadeSubWindows(this); };
	void childEvent(QChildEvent * childEvent) { callbackQWidget_ChildEvent(this, childEvent); };
	void closeActiveSubWindow() { callbackQMdiArea_CloseActiveSubWindow(this); };
	void closeAllSubWindows() { callbackQMdiArea_CloseAllSubWindows(this); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQWidget_EventFilter(this, object, event) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * paintEvent) { callbackQWidget_PaintEvent(this, paintEvent); };
	void resizeEvent(QResizeEvent * resizeEvent) { callbackQWidget_ResizeEvent(this, resizeEvent); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void setActiveSubWindow(QMdiSubWindow * window) { callbackQMdiArea_SetActiveSubWindow(this, window); };
	void setupViewport(QWidget * viewport) { callbackQMdiArea_SetupViewport(this, viewport); };
	void showEvent(QShowEvent * showEvent) { callbackQWidget_ShowEvent(this, showEvent); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_SubWindowActivated(QMdiSubWindow * window) { callbackQMdiArea_SubWindowActivated(this, window); };
	void tileSubWindows() { callbackQMdiArea_TileSubWindows(this); };
	void timerEvent(QTimerEvent * timerEvent) { callbackQWidget_TimerEvent(this, timerEvent); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	 ~MyQMdiArea() { callbackQMdiArea_DestroyQMdiArea(this); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQWidget_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QMdiArea*)
Q_DECLARE_METATYPE(MyQMdiArea*)

int QMdiArea_QMdiArea_QRegisterMetaType(){qRegisterMetaType<QMdiArea*>(); return qRegisterMetaType<MyQMdiArea*>();}

void* QMdiArea_NewQMdiArea(void* parent)
{
		return new MyQMdiArea(static_cast<QWidget*>(parent));
}

void QMdiArea_ActivateNextSubWindow(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "activateNextSubWindow");
}

void QMdiArea_ActivateNextSubWindowDefault(void* ptr)
{
		static_cast<QMdiArea*>(ptr)->QMdiArea::activateNextSubWindow();
}

void QMdiArea_ActivatePreviousSubWindow(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "activatePreviousSubWindow");
}

void QMdiArea_ActivatePreviousSubWindowDefault(void* ptr)
{
		static_cast<QMdiArea*>(ptr)->QMdiArea::activatePreviousSubWindow();
}

long long QMdiArea_ActivationOrder(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->activationOrder();
}

void* QMdiArea_ActiveSubWindow(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->activeSubWindow();
}

void* QMdiArea_AddSubWindow(void* ptr, void* widget, long long windowFlags)
{
		return static_cast<QMdiArea*>(ptr)->addSubWindow(static_cast<QWidget*>(widget), static_cast<Qt::WindowType>(windowFlags));
}

void* QMdiArea_Background(void* ptr)
{
	return new QBrush(static_cast<QMdiArea*>(ptr)->background());
}

void QMdiArea_CascadeSubWindows(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "cascadeSubWindows");
}

void QMdiArea_CascadeSubWindowsDefault(void* ptr)
{
		static_cast<QMdiArea*>(ptr)->QMdiArea::cascadeSubWindows();
}

void QMdiArea_CloseActiveSubWindow(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "closeActiveSubWindow");
}

void QMdiArea_CloseActiveSubWindowDefault(void* ptr)
{
		static_cast<QMdiArea*>(ptr)->QMdiArea::closeActiveSubWindow();
}

void QMdiArea_CloseAllSubWindows(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "closeAllSubWindows");
}

void QMdiArea_CloseAllSubWindowsDefault(void* ptr)
{
		static_cast<QMdiArea*>(ptr)->QMdiArea::closeAllSubWindows();
}

void* QMdiArea_CurrentSubWindow(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->currentSubWindow();
}

char QMdiArea_DocumentMode(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->documentMode();
}

void QMdiArea_RemoveSubWindow(void* ptr, void* widget)
{
		static_cast<QMdiArea*>(ptr)->removeSubWindow(static_cast<QWidget*>(widget));
}

void QMdiArea_SetActivationOrder(void* ptr, long long order)
{
	static_cast<QMdiArea*>(ptr)->setActivationOrder(static_cast<QMdiArea::WindowOrder>(order));
}

void QMdiArea_SetActiveSubWindow(void* ptr, void* window)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setActiveSubWindow", Q_ARG(QMdiSubWindow*, static_cast<QMdiSubWindow*>(window)));
}

void QMdiArea_SetActiveSubWindowDefault(void* ptr, void* window)
{
		static_cast<QMdiArea*>(ptr)->QMdiArea::setActiveSubWindow(static_cast<QMdiSubWindow*>(window));
}

void QMdiArea_SetBackground(void* ptr, void* background)
{
	static_cast<QMdiArea*>(ptr)->setBackground(*static_cast<QBrush*>(background));
}

void QMdiArea_SetDocumentMode(void* ptr, char enabled)
{
	static_cast<QMdiArea*>(ptr)->setDocumentMode(enabled != 0);
}

void QMdiArea_SetOption(void* ptr, long long option, char on)
{
	static_cast<QMdiArea*>(ptr)->setOption(static_cast<QMdiArea::AreaOption>(option), on != 0);
}

void QMdiArea_SetTabPosition(void* ptr, long long position)
{
	static_cast<QMdiArea*>(ptr)->setTabPosition(static_cast<QTabWidget::TabPosition>(position));
}

void QMdiArea_SetTabShape(void* ptr, long long shape)
{
	static_cast<QMdiArea*>(ptr)->setTabShape(static_cast<QTabWidget::TabShape>(shape));
}

void QMdiArea_SetTabsClosable(void* ptr, char closable)
{
	static_cast<QMdiArea*>(ptr)->setTabsClosable(closable != 0);
}

void QMdiArea_SetTabsMovable(void* ptr, char movable)
{
	static_cast<QMdiArea*>(ptr)->setTabsMovable(movable != 0);
}

void QMdiArea_SetViewMode(void* ptr, long long mode)
{
	static_cast<QMdiArea*>(ptr)->setViewMode(static_cast<QMdiArea::ViewMode>(mode));
}

void QMdiArea_SetupViewport(void* ptr, void* viewport)
{
		QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setupViewport", Q_ARG(QWidget*, static_cast<QWidget*>(viewport)));
}

void QMdiArea_SetupViewportDefault(void* ptr, void* viewport)
{
		static_cast<QMdiArea*>(ptr)->QMdiArea::setupViewport(static_cast<QWidget*>(viewport));
}

void QMdiArea_ConnectSubWindowActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QMdiArea*>(ptr), static_cast<void (QMdiArea::*)(QMdiSubWindow *)>(&QMdiArea::subWindowActivated), static_cast<MyQMdiArea*>(ptr), static_cast<void (MyQMdiArea::*)(QMdiSubWindow *)>(&MyQMdiArea::Signal_SubWindowActivated), static_cast<Qt::ConnectionType>(t));
}

void QMdiArea_DisconnectSubWindowActivated(void* ptr)
{
	QObject::disconnect(static_cast<QMdiArea*>(ptr), static_cast<void (QMdiArea::*)(QMdiSubWindow *)>(&QMdiArea::subWindowActivated), static_cast<MyQMdiArea*>(ptr), static_cast<void (MyQMdiArea::*)(QMdiSubWindow *)>(&MyQMdiArea::Signal_SubWindowActivated));
}

void QMdiArea_SubWindowActivated(void* ptr, void* window)
{
	static_cast<QMdiArea*>(ptr)->subWindowActivated(static_cast<QMdiSubWindow*>(window));
}

struct QtWidgets_PackedList QMdiArea_SubWindowList(void* ptr, long long order)
{
	return ({ QList<QMdiSubWindow *>* tmpValuecf1844 = new QList<QMdiSubWindow *>(static_cast<QMdiArea*>(ptr)->subWindowList(static_cast<QMdiArea::WindowOrder>(order))); QtWidgets_PackedList { tmpValuecf1844, tmpValuecf1844->size() }; });
}

long long QMdiArea_TabPosition(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->tabPosition();
}

long long QMdiArea_TabShape(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->tabShape();
}

char QMdiArea_TabsClosable(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->tabsClosable();
}

char QMdiArea_TabsMovable(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->tabsMovable();
}

char QMdiArea_TestOption(void* ptr, long long option)
{
	return static_cast<QMdiArea*>(ptr)->testOption(static_cast<QMdiArea::AreaOption>(option));
}

void QMdiArea_TileSubWindows(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "tileSubWindows");
}

void QMdiArea_TileSubWindowsDefault(void* ptr)
{
		static_cast<QMdiArea*>(ptr)->QMdiArea::tileSubWindows();
}

long long QMdiArea_ViewMode(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->viewMode();
}

void QMdiArea_DestroyQMdiArea(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->~QMdiArea();
}

void QMdiArea_DestroyQMdiAreaDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QMdiArea___subWindowList_atList(void* ptr, int i)
{
	return ({QMdiSubWindow * tmp = static_cast<QList<QMdiSubWindow *>*>(ptr)->at(i); if (i == static_cast<QList<QMdiSubWindow *>*>(ptr)->size()-1) { static_cast<QList<QMdiSubWindow *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QMdiArea___subWindowList_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QMdiSubWindow *>();
}

class MyQMdiSubWindow: public QMdiSubWindow
{
public:
	MyQMdiSubWindow(QWidget *parent = Q_NULLPTR, Qt::WindowFlags flags = Qt::WindowFlags()) : QMdiSubWindow(parent, flags) {QMdiSubWindow_QMdiSubWindow_QRegisterMetaType();};
	void Signal_AboutToActivate() { callbackQMdiSubWindow_AboutToActivate(this); };
	void changeEvent(QEvent * changeEvent) { callbackQWidget_ChangeEvent(this, changeEvent); };
	void childEvent(QChildEvent * childEvent) { callbackQWidget_ChildEvent(this, childEvent); };
	void closeEvent(QCloseEvent * closeEvent) { callbackQWidget_CloseEvent(this, closeEvent); };
	void contextMenuEvent(QContextMenuEvent * contextMenuEvent) { callbackQWidget_ContextMenuEvent(this, contextMenuEvent); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQWidget_EventFilter(this, object, event) != 0; };
	void focusInEvent(QFocusEvent * focusInEvent) { callbackQWidget_FocusInEvent(this, focusInEvent); };
	void focusOutEvent(QFocusEvent * focusOutEvent) { callbackQWidget_FocusOutEvent(this, focusOutEvent); };
	void hideEvent(QHideEvent * hideEvent) { callbackQWidget_HideEvent(this, hideEvent); };
	void keyPressEvent(QKeyEvent * keyEvent) { callbackQWidget_KeyPressEvent(this, keyEvent); };
	void leaveEvent(QEvent * leaveEvent) { callbackQWidget_LeaveEvent(this, leaveEvent); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * mouseEvent) { callbackQWidget_MouseDoubleClickEvent(this, mouseEvent); };
	void mouseMoveEvent(QMouseEvent * mouseEvent) { callbackQWidget_MouseMoveEvent(this, mouseEvent); };
	void mousePressEvent(QMouseEvent * mouseEvent) { callbackQWidget_MousePressEvent(this, mouseEvent); };
	void mouseReleaseEvent(QMouseEvent * mouseEvent) { callbackQWidget_MouseReleaseEvent(this, mouseEvent); };
	void moveEvent(QMoveEvent * moveEvent) { callbackQWidget_MoveEvent(this, moveEvent); };
	void paintEvent(QPaintEvent * paintEvent) { callbackQWidget_PaintEvent(this, paintEvent); };
	void resizeEvent(QResizeEvent * resizeEvent) { callbackQWidget_ResizeEvent(this, resizeEvent); };
	void showEvent(QShowEvent * showEvent) { callbackQWidget_ShowEvent(this, showEvent); };
	void showShaded() { callbackQMdiSubWindow_ShowShaded(this); };
	void showSystemMenu() { callbackQMdiSubWindow_ShowSystemMenu(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void timerEvent(QTimerEvent * timerEvent) { callbackQWidget_TimerEvent(this, timerEvent); };
	void Signal_WindowStateChanged(Qt::WindowStates oldState, Qt::WindowStates newState) { callbackQMdiSubWindow_WindowStateChanged(this, oldState, newState); };
	 ~MyQMdiSubWindow() { callbackQMdiSubWindow_DestroyQMdiSubWindow(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QMdiSubWindow*)
Q_DECLARE_METATYPE(MyQMdiSubWindow*)

int QMdiSubWindow_QMdiSubWindow_QRegisterMetaType(){qRegisterMetaType<QMdiSubWindow*>(); return qRegisterMetaType<MyQMdiSubWindow*>();}

void* QMdiSubWindow_NewQMdiSubWindow(void* parent, long long flags)
{
		return new MyQMdiSubWindow(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}

void QMdiSubWindow_ConnectAboutToActivate(void* ptr, long long t)
{
	QObject::connect(static_cast<QMdiSubWindow*>(ptr), static_cast<void (QMdiSubWindow::*)()>(&QMdiSubWindow::aboutToActivate), static_cast<MyQMdiSubWindow*>(ptr), static_cast<void (MyQMdiSubWindow::*)()>(&MyQMdiSubWindow::Signal_AboutToActivate), static_cast<Qt::ConnectionType>(t));
}

void QMdiSubWindow_DisconnectAboutToActivate(void* ptr)
{
	QObject::disconnect(static_cast<QMdiSubWindow*>(ptr), static_cast<void (QMdiSubWindow::*)()>(&QMdiSubWindow::aboutToActivate), static_cast<MyQMdiSubWindow*>(ptr), static_cast<void (MyQMdiSubWindow::*)()>(&MyQMdiSubWindow::Signal_AboutToActivate));
}

void QMdiSubWindow_AboutToActivate(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->aboutToActivate();
}

char QMdiSubWindow_IsShaded(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->isShaded();
}

int QMdiSubWindow_KeyboardPageStep(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->keyboardPageStep();
}

int QMdiSubWindow_KeyboardSingleStep(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->keyboardSingleStep();
}

void* QMdiSubWindow_MdiArea(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->mdiArea();
}

void QMdiSubWindow_SetKeyboardPageStep(void* ptr, int step)
{
	static_cast<QMdiSubWindow*>(ptr)->setKeyboardPageStep(step);
}

void QMdiSubWindow_SetKeyboardSingleStep(void* ptr, int step)
{
	static_cast<QMdiSubWindow*>(ptr)->setKeyboardSingleStep(step);
}

void QMdiSubWindow_SetOption(void* ptr, long long option, char on)
{
	static_cast<QMdiSubWindow*>(ptr)->setOption(static_cast<QMdiSubWindow::SubWindowOption>(option), on != 0);
}

void QMdiSubWindow_SetSystemMenu(void* ptr, void* systemMenu)
{
	static_cast<QMdiSubWindow*>(ptr)->setSystemMenu(static_cast<QMenu*>(systemMenu));
}

void QMdiSubWindow_SetWidget(void* ptr, void* widget)
{
		static_cast<QMdiSubWindow*>(ptr)->setWidget(static_cast<QWidget*>(widget));
}

void QMdiSubWindow_ShowShaded(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "showShaded");
}

void QMdiSubWindow_ShowShadedDefault(void* ptr)
{
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::showShaded();
}

void QMdiSubWindow_ShowSystemMenu(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "showSystemMenu");
}

void QMdiSubWindow_ShowSystemMenuDefault(void* ptr)
{
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::showSystemMenu();
}

void* QMdiSubWindow_SystemMenu(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->systemMenu();
}

char QMdiSubWindow_TestOption(void* ptr, long long option)
{
	return static_cast<QMdiSubWindow*>(ptr)->testOption(static_cast<QMdiSubWindow::SubWindowOption>(option));
}

void* QMdiSubWindow_Widget(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->widget();
}

void QMdiSubWindow_ConnectWindowStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<Qt::WindowStates>();
	qRegisterMetaType<Qt::WindowStates>();
	QObject::connect(static_cast<QMdiSubWindow*>(ptr), static_cast<void (QMdiSubWindow::*)(Qt::WindowStates, Qt::WindowStates)>(&QMdiSubWindow::windowStateChanged), static_cast<MyQMdiSubWindow*>(ptr), static_cast<void (MyQMdiSubWindow::*)(Qt::WindowStates, Qt::WindowStates)>(&MyQMdiSubWindow::Signal_WindowStateChanged), static_cast<Qt::ConnectionType>(t));
}

void QMdiSubWindow_DisconnectWindowStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMdiSubWindow*>(ptr), static_cast<void (QMdiSubWindow::*)(Qt::WindowStates, Qt::WindowStates)>(&QMdiSubWindow::windowStateChanged), static_cast<MyQMdiSubWindow*>(ptr), static_cast<void (MyQMdiSubWindow::*)(Qt::WindowStates, Qt::WindowStates)>(&MyQMdiSubWindow::Signal_WindowStateChanged));
}

void QMdiSubWindow_WindowStateChanged(void* ptr, long long oldState, long long newState)
{
	static_cast<QMdiSubWindow*>(ptr)->windowStateChanged(static_cast<Qt::WindowState>(oldState), static_cast<Qt::WindowState>(newState));
}

void QMdiSubWindow_DestroyQMdiSubWindow(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->~QMdiSubWindow();
}

void QMdiSubWindow_DestroyQMdiSubWindowDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQMenu: public QMenu
{
public:
	MyQMenu(QWidget *parent = Q_NULLPTR) : QMenu(parent) {QMenu_QMenu_QRegisterMetaType();};
	MyQMenu(const QString &title, QWidget *parent = Q_NULLPTR) : QMenu(title, parent) {QMenu_QMenu_QRegisterMetaType();};
	void Signal_AboutToHide() { callbackQMenu_AboutToHide(this); };
	void Signal_AboutToShow() { callbackQMenu_AboutToShow(this); };
	void actionEvent(QActionEvent * e) { callbackQWidget_ActionEvent(this, e); };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void enterEvent(QEvent * vqe) { callbackQWidget_EnterEvent(this, vqe); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void hideEvent(QHideEvent * vqh) { callbackQWidget_HideEvent(this, vqh); };
	void Signal_Hovered(QAction * action) { callbackQMenu_Hovered(this, action); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void leaveEvent(QEvent * vqe) { callbackQWidget_LeaveEvent(this, vqe); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQWidget_PaintEvent(this, e); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void Signal_Triggered(QAction * action) { callbackQMenu_Triggered(this, action); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	 ~MyQMenu() { callbackQMenu_DestroyQMenu(this); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QMenu*)
Q_DECLARE_METATYPE(MyQMenu*)

int QMenu_QMenu_QRegisterMetaType(){qRegisterMetaType<QMenu*>(); return qRegisterMetaType<MyQMenu*>();}

void* QMenu_NewQMenu(void* parent)
{
		return new MyQMenu(static_cast<QWidget*>(parent));
}

void* QMenu_NewQMenu2(struct QtWidgets_PackedString title, void* parent)
{
		return new MyQMenu(QString::fromUtf8(title.data, title.len), static_cast<QWidget*>(parent));
}

void QMenu_ConnectAboutToHide(void* ptr, long long t)
{
	QObject::connect(static_cast<QMenu*>(ptr), static_cast<void (QMenu::*)()>(&QMenu::aboutToHide), static_cast<MyQMenu*>(ptr), static_cast<void (MyQMenu::*)()>(&MyQMenu::Signal_AboutToHide), static_cast<Qt::ConnectionType>(t));
}

void QMenu_DisconnectAboutToHide(void* ptr)
{
	QObject::disconnect(static_cast<QMenu*>(ptr), static_cast<void (QMenu::*)()>(&QMenu::aboutToHide), static_cast<MyQMenu*>(ptr), static_cast<void (MyQMenu::*)()>(&MyQMenu::Signal_AboutToHide));
}

void QMenu_AboutToHide(void* ptr)
{
	static_cast<QMenu*>(ptr)->aboutToHide();
}

void QMenu_ConnectAboutToShow(void* ptr, long long t)
{
	QObject::connect(static_cast<QMenu*>(ptr), static_cast<void (QMenu::*)()>(&QMenu::aboutToShow), static_cast<MyQMenu*>(ptr), static_cast<void (MyQMenu::*)()>(&MyQMenu::Signal_AboutToShow), static_cast<Qt::ConnectionType>(t));
}

void QMenu_DisconnectAboutToShow(void* ptr)
{
	QObject::disconnect(static_cast<QMenu*>(ptr), static_cast<void (QMenu::*)()>(&QMenu::aboutToShow), static_cast<MyQMenu*>(ptr), static_cast<void (MyQMenu::*)()>(&MyQMenu::Signal_AboutToShow));
}

void QMenu_AboutToShow(void* ptr)
{
	static_cast<QMenu*>(ptr)->aboutToShow();
}

void* QMenu_ActionAt(void* ptr, void* pt)
{
	return static_cast<QMenu*>(ptr)->actionAt(*static_cast<QPoint*>(pt));
}

void* QMenu_ActionGeometry(void* ptr, void* act)
{
	return ({ QRect tmpValue = static_cast<QMenu*>(ptr)->actionGeometry(static_cast<QAction*>(act)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QMenu_ActiveAction(void* ptr)
{
	return static_cast<QMenu*>(ptr)->activeAction();
}

void* QMenu_AddAction(void* ptr, struct QtWidgets_PackedString text)
{
	return static_cast<QMenu*>(ptr)->addAction(QString::fromUtf8(text.data, text.len));
}

void* QMenu_AddAction2(void* ptr, void* icon, struct QtWidgets_PackedString text)
{
	return static_cast<QMenu*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len));
}

void* QMenu_AddAction3(void* ptr, struct QtWidgets_PackedString text, void* receiver, char* member, void* shortcut)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(receiver))) {
		return static_cast<QMenu*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsObject*>(receiver), const_cast<const char*>(member), *static_cast<QKeySequence*>(shortcut));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(receiver))) {
		return static_cast<QMenu*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsWidget*>(receiver), const_cast<const char*>(member), *static_cast<QKeySequence*>(shortcut));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(receiver))) {
		return static_cast<QMenu*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QLayout*>(receiver), const_cast<const char*>(member), *static_cast<QKeySequence*>(shortcut));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(receiver))) {
		return static_cast<QMenu*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(receiver), const_cast<const char*>(member), *static_cast<QKeySequence*>(shortcut));
	} else {
		return static_cast<QMenu*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QObject*>(receiver), const_cast<const char*>(member), *static_cast<QKeySequence*>(shortcut));
	}
}

void* QMenu_AddAction4(void* ptr, void* icon, struct QtWidgets_PackedString text, void* receiver, char* member, void* shortcut)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(receiver))) {
		return static_cast<QMenu*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QGraphicsObject*>(receiver), const_cast<const char*>(member), *static_cast<QKeySequence*>(shortcut));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(receiver))) {
		return static_cast<QMenu*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QGraphicsWidget*>(receiver), const_cast<const char*>(member), *static_cast<QKeySequence*>(shortcut));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(receiver))) {
		return static_cast<QMenu*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QLayout*>(receiver), const_cast<const char*>(member), *static_cast<QKeySequence*>(shortcut));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(receiver))) {
		return static_cast<QMenu*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(receiver), const_cast<const char*>(member), *static_cast<QKeySequence*>(shortcut));
	} else {
		return static_cast<QMenu*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QObject*>(receiver), const_cast<const char*>(member), *static_cast<QKeySequence*>(shortcut));
	}
}

void* QMenu_AddMenu(void* ptr, void* menu)
{
	return static_cast<QMenu*>(ptr)->addMenu(static_cast<QMenu*>(menu));
}

void* QMenu_AddMenu2(void* ptr, struct QtWidgets_PackedString title)
{
	return static_cast<QMenu*>(ptr)->addMenu(QString::fromUtf8(title.data, title.len));
}

void* QMenu_AddMenu3(void* ptr, void* icon, struct QtWidgets_PackedString title)
{
	return static_cast<QMenu*>(ptr)->addMenu(*static_cast<QIcon*>(icon), QString::fromUtf8(title.data, title.len));
}

void* QMenu_AddSection(void* ptr, struct QtWidgets_PackedString text)
{
	return static_cast<QMenu*>(ptr)->addSection(QString::fromUtf8(text.data, text.len));
}

void* QMenu_AddSection2(void* ptr, void* icon, struct QtWidgets_PackedString text)
{
	return static_cast<QMenu*>(ptr)->addSection(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len));
}

void* QMenu_AddSeparator(void* ptr)
{
	return static_cast<QMenu*>(ptr)->addSeparator();
}

void QMenu_Clear(void* ptr)
{
	static_cast<QMenu*>(ptr)->clear();
}

int QMenu_ColumnCount(void* ptr)
{
	return static_cast<QMenu*>(ptr)->columnCount();
}

void* QMenu_DefaultAction(void* ptr)
{
	return static_cast<QMenu*>(ptr)->defaultAction();
}

void* QMenu_Exec(void* ptr)
{
	return static_cast<QMenu*>(ptr)->exec();
}

void* QMenu_Exec2(void* ptr, void* p, void* action)
{
	return static_cast<QMenu*>(ptr)->exec(*static_cast<QPoint*>(p), static_cast<QAction*>(action));
}

void* QMenu_QMenu_Exec3(void* actions, void* pos, void* at, void* parent)
{
		return QMenu::exec(({ QList<QAction *>* tmpP = static_cast<QList<QAction *>*>(actions); QList<QAction *> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }), *static_cast<QPoint*>(pos), static_cast<QAction*>(at), static_cast<QWidget*>(parent));
}

void QMenu_HideTearOffMenu(void* ptr)
{
	static_cast<QMenu*>(ptr)->hideTearOffMenu();
}

void QMenu_ConnectHovered(void* ptr, long long t)
{
	QObject::connect(static_cast<QMenu*>(ptr), static_cast<void (QMenu::*)(QAction *)>(&QMenu::hovered), static_cast<MyQMenu*>(ptr), static_cast<void (MyQMenu::*)(QAction *)>(&MyQMenu::Signal_Hovered), static_cast<Qt::ConnectionType>(t));
}

void QMenu_DisconnectHovered(void* ptr)
{
	QObject::disconnect(static_cast<QMenu*>(ptr), static_cast<void (QMenu::*)(QAction *)>(&QMenu::hovered), static_cast<MyQMenu*>(ptr), static_cast<void (MyQMenu::*)(QAction *)>(&MyQMenu::Signal_Hovered));
}

void QMenu_Hovered(void* ptr, void* action)
{
	static_cast<QMenu*>(ptr)->hovered(static_cast<QAction*>(action));
}

void* QMenu_Icon(void* ptr)
{
	return new QIcon(static_cast<QMenu*>(ptr)->icon());
}

void QMenu_InitStyleOption(void* ptr, void* option, void* action)
{
	static_cast<QMenu*>(ptr)->initStyleOption(static_cast<QStyleOptionMenuItem*>(option), static_cast<QAction*>(action));
}

void* QMenu_InsertMenu(void* ptr, void* before, void* menu)
{
	return static_cast<QMenu*>(ptr)->insertMenu(static_cast<QAction*>(before), static_cast<QMenu*>(menu));
}

void* QMenu_InsertSection(void* ptr, void* before, struct QtWidgets_PackedString text)
{
	return static_cast<QMenu*>(ptr)->insertSection(static_cast<QAction*>(before), QString::fromUtf8(text.data, text.len));
}

void* QMenu_InsertSection2(void* ptr, void* before, void* icon, struct QtWidgets_PackedString text)
{
	return static_cast<QMenu*>(ptr)->insertSection(static_cast<QAction*>(before), *static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len));
}

void* QMenu_InsertSeparator(void* ptr, void* before)
{
	return static_cast<QMenu*>(ptr)->insertSeparator(static_cast<QAction*>(before));
}

char QMenu_IsEmpty(void* ptr)
{
	return static_cast<QMenu*>(ptr)->isEmpty();
}

char QMenu_IsTearOffEnabled(void* ptr)
{
	return static_cast<QMenu*>(ptr)->isTearOffEnabled();
}

char QMenu_IsTearOffMenuVisible(void* ptr)
{
	return static_cast<QMenu*>(ptr)->isTearOffMenuVisible();
}

void* QMenu_MenuAction(void* ptr)
{
	return static_cast<QMenu*>(ptr)->menuAction();
}

void QMenu_Popup(void* ptr, void* p, void* atAction)
{
	static_cast<QMenu*>(ptr)->popup(*static_cast<QPoint*>(p), static_cast<QAction*>(atAction));
}

char QMenu_SeparatorsCollapsible(void* ptr)
{
	return static_cast<QMenu*>(ptr)->separatorsCollapsible();
}

void QMenu_SetActiveAction(void* ptr, void* act)
{
	static_cast<QMenu*>(ptr)->setActiveAction(static_cast<QAction*>(act));
}

void QMenu_SetAsDockMenu(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMenu*>(ptr)->setAsDockMenu();
#endif
}

void QMenu_SetDefaultAction(void* ptr, void* act)
{
	static_cast<QMenu*>(ptr)->setDefaultAction(static_cast<QAction*>(act));
}

void QMenu_SetIcon(void* ptr, void* icon)
{
	static_cast<QMenu*>(ptr)->setIcon(*static_cast<QIcon*>(icon));
}

void QMenu_SetSeparatorsCollapsible(void* ptr, char collapse)
{
	static_cast<QMenu*>(ptr)->setSeparatorsCollapsible(collapse != 0);
}

void QMenu_SetTearOffEnabled(void* ptr, char vbo)
{
	static_cast<QMenu*>(ptr)->setTearOffEnabled(vbo != 0);
}

void QMenu_SetTitle(void* ptr, struct QtWidgets_PackedString title)
{
	static_cast<QMenu*>(ptr)->setTitle(QString::fromUtf8(title.data, title.len));
}

void QMenu_SetToolTipsVisible(void* ptr, char visible)
{
	static_cast<QMenu*>(ptr)->setToolTipsVisible(visible != 0);
}

void QMenu_ShowTearOffMenu(void* ptr, void* pos)
{
	static_cast<QMenu*>(ptr)->showTearOffMenu(*static_cast<QPoint*>(pos));
}

void QMenu_ShowTearOffMenu2(void* ptr)
{
	static_cast<QMenu*>(ptr)->showTearOffMenu();
}

struct QtWidgets_PackedString QMenu_Title(void* ptr)
{
	return ({ QByteArray* tbbbdf8 = new QByteArray(static_cast<QMenu*>(ptr)->title().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tbbbdf8->prepend("WHITESPACE").constData()+10), tbbbdf8->size()-10, tbbbdf8 }; });
}

char QMenu_ToolTipsVisible(void* ptr)
{
	return static_cast<QMenu*>(ptr)->toolTipsVisible();
}

void QMenu_ConnectTriggered(void* ptr, long long t)
{
	QObject::connect(static_cast<QMenu*>(ptr), static_cast<void (QMenu::*)(QAction *)>(&QMenu::triggered), static_cast<MyQMenu*>(ptr), static_cast<void (MyQMenu::*)(QAction *)>(&MyQMenu::Signal_Triggered), static_cast<Qt::ConnectionType>(t));
}

void QMenu_DisconnectTriggered(void* ptr)
{
	QObject::disconnect(static_cast<QMenu*>(ptr), static_cast<void (QMenu::*)(QAction *)>(&QMenu::triggered), static_cast<MyQMenu*>(ptr), static_cast<void (MyQMenu::*)(QAction *)>(&MyQMenu::Signal_Triggered));
}

void QMenu_Triggered(void* ptr, void* action)
{
	static_cast<QMenu*>(ptr)->triggered(static_cast<QAction*>(action));
}

void QMenu_DestroyQMenu(void* ptr)
{
	static_cast<QMenu*>(ptr)->~QMenu();
}

void QMenu_DestroyQMenuDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QMenu___exec_actions_atList3(void* ptr, int i)
{
	return ({QAction * tmp = static_cast<QList<QAction *>*>(ptr)->at(i); if (i == static_cast<QList<QAction *>*>(ptr)->size()-1) { static_cast<QList<QAction *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QMenu___exec_actions_newList3(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAction *>();
}

class MyQMenuBar: public QMenuBar
{
public:
	MyQMenuBar(QWidget *parent = Q_NULLPTR) : QMenuBar(parent) {QMenuBar_QMenuBar_QRegisterMetaType();};
	void actionEvent(QActionEvent * e) { callbackQWidget_ActionEvent(this, e); };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQWidget_EventFilter(this, object, event) != 0; };
	void focusInEvent(QFocusEvent * vqf) { callbackQWidget_FocusInEvent(this, vqf); };
	void focusOutEvent(QFocusEvent * vqf) { callbackQWidget_FocusOutEvent(this, vqf); };
	int heightForWidth(int vin) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), vin); };
	void Signal_Hovered(QAction * action) { callbackQMenuBar_Hovered(this, action); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void leaveEvent(QEvent * vqe) { callbackQWidget_LeaveEvent(this, vqe); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQWidget_PaintEvent(this, e); };
	void resizeEvent(QResizeEvent * vqr) { callbackQWidget_ResizeEvent(this, vqr); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void Signal_Triggered(QAction * action) { callbackQMenuBar_Triggered(this, action); };
	 ~MyQMenuBar() { callbackQMenuBar_DestroyQMenuBar(this); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QMenuBar*)
Q_DECLARE_METATYPE(MyQMenuBar*)

int QMenuBar_QMenuBar_QRegisterMetaType(){qRegisterMetaType<QMenuBar*>(); return qRegisterMetaType<MyQMenuBar*>();}

void* QMenuBar_NewQMenuBar(void* parent)
{
		return new MyQMenuBar(static_cast<QWidget*>(parent));
}

void* QMenuBar_ActionAt(void* ptr, void* pt)
{
	return static_cast<QMenuBar*>(ptr)->actionAt(*static_cast<QPoint*>(pt));
}

void* QMenuBar_ActionGeometry(void* ptr, void* act)
{
	return ({ QRect tmpValue = static_cast<QMenuBar*>(ptr)->actionGeometry(static_cast<QAction*>(act)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QMenuBar_ActiveAction(void* ptr)
{
	return static_cast<QMenuBar*>(ptr)->activeAction();
}

void* QMenuBar_AddAction(void* ptr, struct QtWidgets_PackedString text)
{
	return static_cast<QMenuBar*>(ptr)->addAction(QString::fromUtf8(text.data, text.len));
}

void* QMenuBar_AddAction2(void* ptr, struct QtWidgets_PackedString text, void* receiver, char* member)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(receiver))) {
		return static_cast<QMenuBar*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsObject*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(receiver))) {
		return static_cast<QMenuBar*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsWidget*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(receiver))) {
		return static_cast<QMenuBar*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QLayout*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(receiver))) {
		return static_cast<QMenuBar*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(receiver), const_cast<const char*>(member));
	} else {
		return static_cast<QMenuBar*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QObject*>(receiver), const_cast<const char*>(member));
	}
}

void* QMenuBar_AddMenu(void* ptr, void* menu)
{
	return static_cast<QMenuBar*>(ptr)->addMenu(static_cast<QMenu*>(menu));
}

void* QMenuBar_AddMenu2(void* ptr, struct QtWidgets_PackedString title)
{
	return static_cast<QMenuBar*>(ptr)->addMenu(QString::fromUtf8(title.data, title.len));
}

void* QMenuBar_AddMenu3(void* ptr, void* icon, struct QtWidgets_PackedString title)
{
	return static_cast<QMenuBar*>(ptr)->addMenu(*static_cast<QIcon*>(icon), QString::fromUtf8(title.data, title.len));
}

void* QMenuBar_AddSeparator(void* ptr)
{
	return static_cast<QMenuBar*>(ptr)->addSeparator();
}

void QMenuBar_Clear(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->clear();
}

void* QMenuBar_CornerWidget(void* ptr, long long corner)
{
	return static_cast<QMenuBar*>(ptr)->cornerWidget(static_cast<Qt::Corner>(corner));
}

void QMenuBar_ConnectHovered(void* ptr, long long t)
{
	QObject::connect(static_cast<QMenuBar*>(ptr), static_cast<void (QMenuBar::*)(QAction *)>(&QMenuBar::hovered), static_cast<MyQMenuBar*>(ptr), static_cast<void (MyQMenuBar::*)(QAction *)>(&MyQMenuBar::Signal_Hovered), static_cast<Qt::ConnectionType>(t));
}

void QMenuBar_DisconnectHovered(void* ptr)
{
	QObject::disconnect(static_cast<QMenuBar*>(ptr), static_cast<void (QMenuBar::*)(QAction *)>(&QMenuBar::hovered), static_cast<MyQMenuBar*>(ptr), static_cast<void (MyQMenuBar::*)(QAction *)>(&MyQMenuBar::Signal_Hovered));
}

void QMenuBar_Hovered(void* ptr, void* action)
{
	static_cast<QMenuBar*>(ptr)->hovered(static_cast<QAction*>(action));
}

void QMenuBar_InitStyleOption(void* ptr, void* option, void* action)
{
	static_cast<QMenuBar*>(ptr)->initStyleOption(static_cast<QStyleOptionMenuItem*>(option), static_cast<QAction*>(action));
}

void* QMenuBar_InsertMenu(void* ptr, void* before, void* menu)
{
	return static_cast<QMenuBar*>(ptr)->insertMenu(static_cast<QAction*>(before), static_cast<QMenu*>(menu));
}

void* QMenuBar_InsertSeparator(void* ptr, void* before)
{
	return static_cast<QMenuBar*>(ptr)->insertSeparator(static_cast<QAction*>(before));
}

char QMenuBar_IsDefaultUp(void* ptr)
{
	return static_cast<QMenuBar*>(ptr)->isDefaultUp();
}

char QMenuBar_IsNativeMenuBar(void* ptr)
{
	return static_cast<QMenuBar*>(ptr)->isNativeMenuBar();
}

void QMenuBar_SetActiveAction(void* ptr, void* act)
{
	static_cast<QMenuBar*>(ptr)->setActiveAction(static_cast<QAction*>(act));
}

void QMenuBar_SetCornerWidget(void* ptr, void* widget, long long corner)
{
		static_cast<QMenuBar*>(ptr)->setCornerWidget(static_cast<QWidget*>(widget), static_cast<Qt::Corner>(corner));
}

void QMenuBar_SetDefaultUp(void* ptr, char vbo)
{
	static_cast<QMenuBar*>(ptr)->setDefaultUp(vbo != 0);
}

void QMenuBar_SetNativeMenuBar(void* ptr, char nativeMenuBar)
{
	static_cast<QMenuBar*>(ptr)->setNativeMenuBar(nativeMenuBar != 0);
}

void QMenuBar_ConnectTriggered(void* ptr, long long t)
{
	QObject::connect(static_cast<QMenuBar*>(ptr), static_cast<void (QMenuBar::*)(QAction *)>(&QMenuBar::triggered), static_cast<MyQMenuBar*>(ptr), static_cast<void (MyQMenuBar::*)(QAction *)>(&MyQMenuBar::Signal_Triggered), static_cast<Qt::ConnectionType>(t));
}

void QMenuBar_DisconnectTriggered(void* ptr)
{
	QObject::disconnect(static_cast<QMenuBar*>(ptr), static_cast<void (QMenuBar::*)(QAction *)>(&QMenuBar::triggered), static_cast<MyQMenuBar*>(ptr), static_cast<void (MyQMenuBar::*)(QAction *)>(&MyQMenuBar::Signal_Triggered));
}

void QMenuBar_Triggered(void* ptr, void* action)
{
	static_cast<QMenuBar*>(ptr)->triggered(static_cast<QAction*>(action));
}

void QMenuBar_DestroyQMenuBar(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->~QMenuBar();
}

void QMenuBar_DestroyQMenuBarDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQMessageBox: public QMessageBox
{
public:
	MyQMessageBox(QWidget *parent = Q_NULLPTR) : QMessageBox(parent) {QMessageBox_QMessageBox_QRegisterMetaType();};
	MyQMessageBox(QMessageBox::Icon icon, const QString &title, const QString &text, QMessageBox::StandardButtons buttons = NoButton, QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint) : QMessageBox(icon, title, text, buttons, parent, ff) {QMessageBox_QMessageBox_QRegisterMetaType();};
	void Signal_ButtonClicked(QAbstractButton * button) { callbackQMessageBox_ButtonClicked(this, button); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void closeEvent(QCloseEvent * e) { callbackQWidget_CloseEvent(this, e); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	int exec() { return callbackQDialog_Exec(this); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void showEvent(QShowEvent * e) { callbackQWidget_ShowEvent(this, e); };
	 ~MyQMessageBox() { callbackQMessageBox_DestroyQMessageBox(this); };
	void accept() { callbackQDialog_Accept(this); };
	void Signal_Accepted() { callbackQDialog_Accepted(this); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	void done(int r) { callbackQDialog_Done(this, r); };
	bool eventFilter(QObject * o, QEvent * e) { return callbackQWidget_EventFilter(this, o, e) != 0; };
	void Signal_Finished(int result) { callbackQDialog_Finished(this, result); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void reject() { callbackQDialog_Reject(this); };
	void Signal_Rejected() { callbackQDialog_Rejected(this); };
	void setVisible(bool visible) { callbackQDialog_SetVisible(this, visible); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMessageBox*)
Q_DECLARE_METATYPE(MyQMessageBox*)

int QMessageBox_QMessageBox_QRegisterMetaType(){qRegisterMetaType<QMessageBox*>(); return qRegisterMetaType<MyQMessageBox*>();}

int QMessageBox_ButtonMask_Type()
{
	return QMessageBox::ButtonMask;
}

void* QMessageBox_NewQMessageBox(void* parent)
{
		return new MyQMessageBox(static_cast<QWidget*>(parent));
}

void* QMessageBox_NewQMessageBox2(long long icon, struct QtWidgets_PackedString title, struct QtWidgets_PackedString text, long long buttons, void* parent, long long ff)
{
		return new MyQMessageBox(static_cast<QMessageBox::Icon>(icon), QString::fromUtf8(title.data, title.len), QString::fromUtf8(text.data, text.len), static_cast<QMessageBox::StandardButton>(buttons), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}

void QMessageBox_QMessageBox_About(void* parent, struct QtWidgets_PackedString title, struct QtWidgets_PackedString text)
{
		QMessageBox::about(static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len), QString::fromUtf8(text.data, text.len));
}

void QMessageBox_QMessageBox_AboutQt(void* parent, struct QtWidgets_PackedString title)
{
		QMessageBox::aboutQt(static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len));
}

void QMessageBox_AddButton(void* ptr, void* button, long long role)
{
	static_cast<QMessageBox*>(ptr)->addButton(static_cast<QAbstractButton*>(button), static_cast<QMessageBox::ButtonRole>(role));
}

void* QMessageBox_AddButton2(void* ptr, struct QtWidgets_PackedString text, long long role)
{
	return static_cast<QMessageBox*>(ptr)->addButton(QString::fromUtf8(text.data, text.len), static_cast<QMessageBox::ButtonRole>(role));
}

void* QMessageBox_AddButton3(void* ptr, long long button)
{
	return static_cast<QMessageBox*>(ptr)->addButton(static_cast<QMessageBox::StandardButton>(button));
}

void* QMessageBox_Button(void* ptr, long long which)
{
	return static_cast<QMessageBox*>(ptr)->button(static_cast<QMessageBox::StandardButton>(which));
}

void QMessageBox_ConnectButtonClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QMessageBox*>(ptr), static_cast<void (QMessageBox::*)(QAbstractButton *)>(&QMessageBox::buttonClicked), static_cast<MyQMessageBox*>(ptr), static_cast<void (MyQMessageBox::*)(QAbstractButton *)>(&MyQMessageBox::Signal_ButtonClicked), static_cast<Qt::ConnectionType>(t));
}

void QMessageBox_DisconnectButtonClicked(void* ptr)
{
	QObject::disconnect(static_cast<QMessageBox*>(ptr), static_cast<void (QMessageBox::*)(QAbstractButton *)>(&QMessageBox::buttonClicked), static_cast<MyQMessageBox*>(ptr), static_cast<void (MyQMessageBox::*)(QAbstractButton *)>(&MyQMessageBox::Signal_ButtonClicked));
}

void QMessageBox_ButtonClicked(void* ptr, void* button)
{
	static_cast<QMessageBox*>(ptr)->buttonClicked(static_cast<QAbstractButton*>(button));
}

long long QMessageBox_ButtonRole(void* ptr, void* button)
{
	return static_cast<QMessageBox*>(ptr)->buttonRole(static_cast<QAbstractButton*>(button));
}

struct QtWidgets_PackedList QMessageBox_Buttons(void* ptr)
{
	return ({ QList<QAbstractButton *>* tmpValuef25e9a = new QList<QAbstractButton *>(static_cast<QMessageBox*>(ptr)->buttons()); QtWidgets_PackedList { tmpValuef25e9a, tmpValuef25e9a->size() }; });
}

void* QMessageBox_CheckBox(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->checkBox();
}

void* QMessageBox_ClickedButton(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->clickedButton();
}

long long QMessageBox_QMessageBox_Critical(void* parent, struct QtWidgets_PackedString title, struct QtWidgets_PackedString text, long long buttons, long long defaultButton)
{
		return QMessageBox::critical(static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len), QString::fromUtf8(text.data, text.len), static_cast<QMessageBox::StandardButton>(buttons), static_cast<QMessageBox::StandardButton>(defaultButton));
}

void* QMessageBox_DefaultButton(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->defaultButton();
}

struct QtWidgets_PackedString QMessageBox_DetailedText(void* ptr)
{
	return ({ QByteArray* t9d0340 = new QByteArray(static_cast<QMessageBox*>(ptr)->detailedText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t9d0340->prepend("WHITESPACE").constData()+10), t9d0340->size()-10, t9d0340 }; });
}

void* QMessageBox_EscapeButton(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->escapeButton();
}

long long QMessageBox_Icon(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->icon();
}

void* QMessageBox_IconPixmap(void* ptr)
{
	return new QPixmap(static_cast<QMessageBox*>(ptr)->iconPixmap());
}

long long QMessageBox_QMessageBox_Information(void* parent, struct QtWidgets_PackedString title, struct QtWidgets_PackedString text, long long buttons, long long defaultButton)
{
		return QMessageBox::information(static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len), QString::fromUtf8(text.data, text.len), static_cast<QMessageBox::StandardButton>(buttons), static_cast<QMessageBox::StandardButton>(defaultButton));
}

struct QtWidgets_PackedString QMessageBox_InformativeText(void* ptr)
{
	return ({ QByteArray* t0d44bc = new QByteArray(static_cast<QMessageBox*>(ptr)->informativeText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t0d44bc->prepend("WHITESPACE").constData()+10), t0d44bc->size()-10, t0d44bc }; });
}

void QMessageBox_Open(void* ptr, void* receiver, char* member)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(receiver))) {
		static_cast<QMessageBox*>(ptr)->open(static_cast<QGraphicsObject*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(receiver))) {
		static_cast<QMessageBox*>(ptr)->open(static_cast<QGraphicsWidget*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(receiver))) {
		static_cast<QMessageBox*>(ptr)->open(static_cast<QLayout*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(receiver))) {
		static_cast<QMessageBox*>(ptr)->open(static_cast<QWidget*>(receiver), const_cast<const char*>(member));
	} else {
		static_cast<QMessageBox*>(ptr)->open(static_cast<QObject*>(receiver), const_cast<const char*>(member));
	}
}

long long QMessageBox_QMessageBox_Question(void* parent, struct QtWidgets_PackedString title, struct QtWidgets_PackedString text, long long buttons, long long defaultButton)
{
		return QMessageBox::question(static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len), QString::fromUtf8(text.data, text.len), static_cast<QMessageBox::StandardButton>(buttons), static_cast<QMessageBox::StandardButton>(defaultButton));
}

void QMessageBox_RemoveButton(void* ptr, void* button)
{
	static_cast<QMessageBox*>(ptr)->removeButton(static_cast<QAbstractButton*>(button));
}

void QMessageBox_SetCheckBox(void* ptr, void* cb)
{
	static_cast<QMessageBox*>(ptr)->setCheckBox(static_cast<QCheckBox*>(cb));
}

void QMessageBox_SetDefaultButton(void* ptr, void* button)
{
	static_cast<QMessageBox*>(ptr)->setDefaultButton(static_cast<QPushButton*>(button));
}

void QMessageBox_SetDefaultButton2(void* ptr, long long button)
{
	static_cast<QMessageBox*>(ptr)->setDefaultButton(static_cast<QMessageBox::StandardButton>(button));
}

void QMessageBox_SetDetailedText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QMessageBox*>(ptr)->setDetailedText(QString::fromUtf8(text.data, text.len));
}

void QMessageBox_SetEscapeButton(void* ptr, void* button)
{
	static_cast<QMessageBox*>(ptr)->setEscapeButton(static_cast<QAbstractButton*>(button));
}

void QMessageBox_SetEscapeButton2(void* ptr, long long button)
{
	static_cast<QMessageBox*>(ptr)->setEscapeButton(static_cast<QMessageBox::StandardButton>(button));
}

void QMessageBox_SetIcon(void* ptr, long long vqm)
{
	static_cast<QMessageBox*>(ptr)->setIcon(static_cast<QMessageBox::Icon>(vqm));
}

void QMessageBox_SetIconPixmap(void* ptr, void* pixmap)
{
	static_cast<QMessageBox*>(ptr)->setIconPixmap(*static_cast<QPixmap*>(pixmap));
}

void QMessageBox_SetInformativeText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QMessageBox*>(ptr)->setInformativeText(QString::fromUtf8(text.data, text.len));
}

void QMessageBox_SetStandardButtons(void* ptr, long long buttons)
{
	static_cast<QMessageBox*>(ptr)->setStandardButtons(static_cast<QMessageBox::StandardButton>(buttons));
}

void QMessageBox_SetText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QMessageBox*>(ptr)->setText(QString::fromUtf8(text.data, text.len));
}

void QMessageBox_SetTextFormat(void* ptr, long long format)
{
	static_cast<QMessageBox*>(ptr)->setTextFormat(static_cast<Qt::TextFormat>(format));
}

void QMessageBox_SetTextInteractionFlags(void* ptr, long long flags)
{
	static_cast<QMessageBox*>(ptr)->setTextInteractionFlags(static_cast<Qt::TextInteractionFlag>(flags));
}

void QMessageBox_SetWindowTitle(void* ptr, struct QtWidgets_PackedString title)
{
	static_cast<QMessageBox*>(ptr)->setWindowTitle(QString::fromUtf8(title.data, title.len));
}

long long QMessageBox_StandardButton(void* ptr, void* button)
{
	return static_cast<QMessageBox*>(ptr)->standardButton(static_cast<QAbstractButton*>(button));
}

long long QMessageBox_StandardButtons(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->standardButtons();
}

struct QtWidgets_PackedString QMessageBox_Text(void* ptr)
{
	return ({ QByteArray* te2bb59 = new QByteArray(static_cast<QMessageBox*>(ptr)->text().toUtf8()); QtWidgets_PackedString { const_cast<char*>(te2bb59->prepend("WHITESPACE").constData()+10), te2bb59->size()-10, te2bb59 }; });
}

long long QMessageBox_TextFormat(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->textFormat();
}

long long QMessageBox_TextInteractionFlags(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->textInteractionFlags();
}

long long QMessageBox_QMessageBox_Warning(void* parent, struct QtWidgets_PackedString title, struct QtWidgets_PackedString text, long long buttons, long long defaultButton)
{
		return QMessageBox::warning(static_cast<QWidget*>(parent), QString::fromUtf8(title.data, title.len), QString::fromUtf8(text.data, text.len), static_cast<QMessageBox::StandardButton>(buttons), static_cast<QMessageBox::StandardButton>(defaultButton));
}

void QMessageBox_DestroyQMessageBox(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->~QMessageBox();
}

void QMessageBox_DestroyQMessageBoxDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QMessageBox___buttons_atList(void* ptr, int i)
{
	return ({QAbstractButton * tmp = static_cast<QList<QAbstractButton *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractButton *>*>(ptr)->size()-1) { static_cast<QList<QAbstractButton *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QMessageBox___buttons_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAbstractButton *>();
}

class MyQMouseEventTransition: public QMouseEventTransition
{
public:
	MyQMouseEventTransition(QState *sourceState = Q_NULLPTR) : QMouseEventTransition(sourceState) {QMouseEventTransition_QMouseEventTransition_QRegisterMetaType();};
	MyQMouseEventTransition(QObject *object, QEvent::Type ty, Qt::MouseButton button, QState *sourceState = Q_NULLPTR) : QMouseEventTransition(object, ty, button, sourceState) {QMouseEventTransition_QMouseEventTransition_QRegisterMetaType();};
	bool eventTest(QEvent * event) { return callbackQMouseEventTransition_EventTest(this, event) != 0; };
	void onTransition(QEvent * event) { callbackQMouseEventTransition_OnTransition(this, event); };
	 ~MyQMouseEventTransition() { callbackQMouseEventTransition_DestroyQMouseEventTransition(this); };
	bool event(QEvent * e) { return callbackQMouseEventTransition_Event(this, e) != 0; };
	void Signal_TargetStateChanged() { callbackQMouseEventTransition_TargetStateChanged(this); };
	void Signal_TargetStatesChanged() { callbackQMouseEventTransition_TargetStatesChanged(this); };
	void Signal_Triggered() { callbackQMouseEventTransition_Triggered(this); };
	void childEvent(QChildEvent * event) { callbackQMouseEventTransition_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMouseEventTransition_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMouseEventTransition_CustomEvent(this, event); };
	void deleteLater() { callbackQMouseEventTransition_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMouseEventTransition_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMouseEventTransition_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMouseEventTransition_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMouseEventTransition_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQMouseEventTransition_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMouseEventTransition_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QMouseEventTransition*)
Q_DECLARE_METATYPE(MyQMouseEventTransition*)

int QMouseEventTransition_QMouseEventTransition_QRegisterMetaType(){qRegisterMetaType<QMouseEventTransition*>(); return qRegisterMetaType<MyQMouseEventTransition*>();}

void* QMouseEventTransition_NewQMouseEventTransition(void* sourceState)
{
	return new MyQMouseEventTransition(static_cast<QState*>(sourceState));
}

void* QMouseEventTransition_NewQMouseEventTransition2(void* object, long long ty, long long button, void* sourceState)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QAudioSystemPlugin*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QCameraImageCapture*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QDBusPendingCallWatcher*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QExtensionFactory*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QExtensionManager*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QGraphicsObject*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QGraphicsWidget*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QLayout*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QMediaPlaylist*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QMediaRecorder*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QMediaServiceProviderPlugin*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QOffscreenSurface*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QPaintDeviceWindow*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QPdfWriter*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QQuickItem*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QRadioData*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QRemoteObjectPendingCallWatcher*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QScriptExtensionPlugin*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QWidget*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
		return new MyQMouseEventTransition(static_cast<QWindow*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	} else {
		return new MyQMouseEventTransition(static_cast<QObject*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
	}
}

long long QMouseEventTransition_Button(void* ptr)
{
	return static_cast<QMouseEventTransition*>(ptr)->button();
}

char QMouseEventTransition_EventTestDefault(void* ptr, void* event)
{
		return static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::eventTest(static_cast<QEvent*>(event));
}

void* QMouseEventTransition_HitTestPath(void* ptr)
{
	return new QPainterPath(static_cast<QMouseEventTransition*>(ptr)->hitTestPath());
}

long long QMouseEventTransition_ModifierMask(void* ptr)
{
	return static_cast<QMouseEventTransition*>(ptr)->modifierMask();
}

void QMouseEventTransition_OnTransitionDefault(void* ptr, void* event)
{
		static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::onTransition(static_cast<QEvent*>(event));
}

void QMouseEventTransition_SetButton(void* ptr, long long button)
{
	static_cast<QMouseEventTransition*>(ptr)->setButton(static_cast<Qt::MouseButton>(button));
}

void QMouseEventTransition_SetHitTestPath(void* ptr, void* path)
{
	static_cast<QMouseEventTransition*>(ptr)->setHitTestPath(*static_cast<QPainterPath*>(path));
}

void QMouseEventTransition_SetModifierMask(void* ptr, long long modifierMask)
{
	static_cast<QMouseEventTransition*>(ptr)->setModifierMask(static_cast<Qt::KeyboardModifier>(modifierMask));
}

void QMouseEventTransition_DestroyQMouseEventTransition(void* ptr)
{
	static_cast<QMouseEventTransition*>(ptr)->~QMouseEventTransition();
}

void QMouseEventTransition_DestroyQMouseEventTransitionDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QMouseEventTransition___animations_atList(void* ptr, int i)
{
	return ({QAbstractAnimation * tmp = static_cast<QList<QAbstractAnimation *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractAnimation *>*>(ptr)->size()-1) { static_cast<QList<QAbstractAnimation *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QMouseEventTransition___animations_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAbstractAnimation *>();
}

void* QMouseEventTransition___setTargetStates_targets_atList(void* ptr, int i)
{
	return ({QAbstractState * tmp = static_cast<QList<QAbstractState *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractState *>*>(ptr)->size()-1) { static_cast<QList<QAbstractState *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QMouseEventTransition___setTargetStates_targets_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAbstractState *>();
}

void* QMouseEventTransition___targetStates_atList(void* ptr, int i)
{
	return ({QAbstractState * tmp = static_cast<QList<QAbstractState *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractState *>*>(ptr)->size()-1) { static_cast<QList<QAbstractState *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QMouseEventTransition___targetStates_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QAbstractState *>();
}

void* QMouseEventTransition___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMouseEventTransition___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QMouseEventTransition___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QMouseEventTransition___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMouseEventTransition___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QMouseEventTransition___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QMouseEventTransition___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

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

void QMouseEventTransition_DeleteLaterDefault(void* ptr)
{
		static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::deleteLater();
}

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

char QMouseEventTransition_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQOpenGLWidget: public QOpenGLWidget
{
public:
	MyQOpenGLWidget(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QOpenGLWidget(parent, ff) {QOpenGLWidget_QOpenGLWidget_QRegisterMetaType();};
	void Signal_AboutToCompose() { callbackQOpenGLWidget_AboutToCompose(this); };
	void Signal_AboutToResize() { callbackQOpenGLWidget_AboutToResize(this); };
	void Signal_FrameSwapped() { callbackQOpenGLWidget_FrameSwapped(this); };
	void initializeGL() { callbackQOpenGLWidget_InitializeGL(this); };
	void paintEvent(QPaintEvent * e) { callbackQWidget_PaintEvent(this, e); };
	void paintGL() { callbackQOpenGLWidget_PaintGL(this); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void resizeGL(int w, int h) { callbackQOpenGLWidget_ResizeGL(this, w, h); };
	void Signal_Resized() { callbackQOpenGLWidget_Resized(this); };
	 ~MyQOpenGLWidget() { callbackQOpenGLWidget_DestroyQOpenGLWidget(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QOpenGLWidget*)
Q_DECLARE_METATYPE(MyQOpenGLWidget*)

int QOpenGLWidget_QOpenGLWidget_QRegisterMetaType(){qRegisterMetaType<QOpenGLWidget*>(); return qRegisterMetaType<MyQOpenGLWidget*>();}

void* QOpenGLWidget_NewQOpenGLWidget(void* parent, long long ff)
{
		return new MyQOpenGLWidget(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}

void QOpenGLWidget_ConnectAboutToCompose(void* ptr, long long t)
{
	QObject::connect(static_cast<QOpenGLWidget*>(ptr), static_cast<void (QOpenGLWidget::*)()>(&QOpenGLWidget::aboutToCompose), static_cast<MyQOpenGLWidget*>(ptr), static_cast<void (MyQOpenGLWidget::*)()>(&MyQOpenGLWidget::Signal_AboutToCompose), static_cast<Qt::ConnectionType>(t));
}

void QOpenGLWidget_DisconnectAboutToCompose(void* ptr)
{
	QObject::disconnect(static_cast<QOpenGLWidget*>(ptr), static_cast<void (QOpenGLWidget::*)()>(&QOpenGLWidget::aboutToCompose), static_cast<MyQOpenGLWidget*>(ptr), static_cast<void (MyQOpenGLWidget::*)()>(&MyQOpenGLWidget::Signal_AboutToCompose));
}

void QOpenGLWidget_AboutToCompose(void* ptr)
{
	static_cast<QOpenGLWidget*>(ptr)->aboutToCompose();
}

void QOpenGLWidget_ConnectAboutToResize(void* ptr, long long t)
{
	QObject::connect(static_cast<QOpenGLWidget*>(ptr), static_cast<void (QOpenGLWidget::*)()>(&QOpenGLWidget::aboutToResize), static_cast<MyQOpenGLWidget*>(ptr), static_cast<void (MyQOpenGLWidget::*)()>(&MyQOpenGLWidget::Signal_AboutToResize), static_cast<Qt::ConnectionType>(t));
}

void QOpenGLWidget_DisconnectAboutToResize(void* ptr)
{
	QObject::disconnect(static_cast<QOpenGLWidget*>(ptr), static_cast<void (QOpenGLWidget::*)()>(&QOpenGLWidget::aboutToResize), static_cast<MyQOpenGLWidget*>(ptr), static_cast<void (MyQOpenGLWidget::*)()>(&MyQOpenGLWidget::Signal_AboutToResize));
}

void QOpenGLWidget_AboutToResize(void* ptr)
{
	static_cast<QOpenGLWidget*>(ptr)->aboutToResize();
}

void* QOpenGLWidget_Context(void* ptr)
{
	return static_cast<QOpenGLWidget*>(ptr)->context();
}

unsigned int QOpenGLWidget_DefaultFramebufferObject(void* ptr)
{
	return static_cast<QOpenGLWidget*>(ptr)->defaultFramebufferObject();
}

void QOpenGLWidget_DoneCurrent(void* ptr)
{
	static_cast<QOpenGLWidget*>(ptr)->doneCurrent();
}

void* QOpenGLWidget_Format(void* ptr)
{
	return new QSurfaceFormat(static_cast<QOpenGLWidget*>(ptr)->format());
}

void QOpenGLWidget_ConnectFrameSwapped(void* ptr, long long t)
{
	QObject::connect(static_cast<QOpenGLWidget*>(ptr), static_cast<void (QOpenGLWidget::*)()>(&QOpenGLWidget::frameSwapped), static_cast<MyQOpenGLWidget*>(ptr), static_cast<void (MyQOpenGLWidget::*)()>(&MyQOpenGLWidget::Signal_FrameSwapped), static_cast<Qt::ConnectionType>(t));
}

void QOpenGLWidget_DisconnectFrameSwapped(void* ptr)
{
	QObject::disconnect(static_cast<QOpenGLWidget*>(ptr), static_cast<void (QOpenGLWidget::*)()>(&QOpenGLWidget::frameSwapped), static_cast<MyQOpenGLWidget*>(ptr), static_cast<void (MyQOpenGLWidget::*)()>(&MyQOpenGLWidget::Signal_FrameSwapped));
}

void QOpenGLWidget_FrameSwapped(void* ptr)
{
	static_cast<QOpenGLWidget*>(ptr)->frameSwapped();
}

void* QOpenGLWidget_GrabFramebuffer(void* ptr)
{
	return new QImage(static_cast<QOpenGLWidget*>(ptr)->grabFramebuffer());
}

void QOpenGLWidget_InitializeGL(void* ptr)
{
	static_cast<QOpenGLWidget*>(ptr)->initializeGL();
}

void QOpenGLWidget_InitializeGLDefault(void* ptr)
{
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::initializeGL();
}

char QOpenGLWidget_IsValid(void* ptr)
{
	return static_cast<QOpenGLWidget*>(ptr)->isValid();
}

void QOpenGLWidget_MakeCurrent(void* ptr)
{
	static_cast<QOpenGLWidget*>(ptr)->makeCurrent();
}

void QOpenGLWidget_PaintGL(void* ptr)
{
	static_cast<QOpenGLWidget*>(ptr)->paintGL();
}

void QOpenGLWidget_PaintGLDefault(void* ptr)
{
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::paintGL();
}

void QOpenGLWidget_ResizeGL(void* ptr, int w, int h)
{
	static_cast<QOpenGLWidget*>(ptr)->resizeGL(w, h);
}

void QOpenGLWidget_ResizeGLDefault(void* ptr, int w, int h)
{
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::resizeGL(w, h);
}

void QOpenGLWidget_ConnectResized(void* ptr, long long t)
{
	QObject::connect(static_cast<QOpenGLWidget*>(ptr), static_cast<void (QOpenGLWidget::*)()>(&QOpenGLWidget::resized), static_cast<MyQOpenGLWidget*>(ptr), static_cast<void (MyQOpenGLWidget::*)()>(&MyQOpenGLWidget::Signal_Resized), static_cast<Qt::ConnectionType>(t));
}

void QOpenGLWidget_DisconnectResized(void* ptr)
{
	QObject::disconnect(static_cast<QOpenGLWidget*>(ptr), static_cast<void (QOpenGLWidget::*)()>(&QOpenGLWidget::resized), static_cast<MyQOpenGLWidget*>(ptr), static_cast<void (MyQOpenGLWidget::*)()>(&MyQOpenGLWidget::Signal_Resized));
}

void QOpenGLWidget_Resized(void* ptr)
{
	static_cast<QOpenGLWidget*>(ptr)->resized();
}

void QOpenGLWidget_SetFormat(void* ptr, void* format)
{
	static_cast<QOpenGLWidget*>(ptr)->setFormat(*static_cast<QSurfaceFormat*>(format));
}

void QOpenGLWidget_SetTextureFormat(void* ptr, unsigned int texFormat)
{
	static_cast<QOpenGLWidget*>(ptr)->setTextureFormat(texFormat);
}

void QOpenGLWidget_SetUpdateBehavior(void* ptr, long long updateBehavior)
{
	static_cast<QOpenGLWidget*>(ptr)->setUpdateBehavior(static_cast<QOpenGLWidget::UpdateBehavior>(updateBehavior));
}

unsigned int QOpenGLWidget_TextureFormat(void* ptr)
{
	return static_cast<QOpenGLWidget*>(ptr)->textureFormat();
}

long long QOpenGLWidget_UpdateBehavior(void* ptr)
{
	return static_cast<QOpenGLWidget*>(ptr)->updateBehavior();
}

void QOpenGLWidget_DestroyQOpenGLWidget(void* ptr)
{
	static_cast<QOpenGLWidget*>(ptr)->~QOpenGLWidget();
}

void QOpenGLWidget_DestroyQOpenGLWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQPanGesture: public QPanGesture
{
public:
	 ~MyQPanGesture() { callbackQPanGesture_DestroyQPanGesture(this); };
	void childEvent(QChildEvent * event) { callbackQGesture_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGesture_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGesture_CustomEvent(this, event); };
	void deleteLater() { callbackQGesture_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGesture_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGesture_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGesture_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGesture_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGesture_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGesture_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGesture_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QPanGesture*)
Q_DECLARE_METATYPE(MyQPanGesture*)

int QPanGesture_QPanGesture_QRegisterMetaType(){qRegisterMetaType<QPanGesture*>(); return qRegisterMetaType<MyQPanGesture*>();}

double QPanGesture_Acceleration(void* ptr)
{
	return static_cast<QPanGesture*>(ptr)->acceleration();
}

void* QPanGesture_Delta(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QPanGesture*>(ptr)->delta(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QPanGesture_LastOffset(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QPanGesture*>(ptr)->lastOffset(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QPanGesture_Offset(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QPanGesture*>(ptr)->offset(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QPanGesture_SetAcceleration(void* ptr, double value)
{
	static_cast<QPanGesture*>(ptr)->setAcceleration(value);
}

void QPanGesture_SetLastOffset(void* ptr, void* value)
{
	static_cast<QPanGesture*>(ptr)->setLastOffset(*static_cast<QPointF*>(value));
}

void QPanGesture_SetOffset(void* ptr, void* value)
{
	static_cast<QPanGesture*>(ptr)->setOffset(*static_cast<QPointF*>(value));
}

void QPanGesture_DestroyQPanGesture(void* ptr)
{
	static_cast<QPanGesture*>(ptr)->~QPanGesture();
}

void QPanGesture_DestroyQPanGestureDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQPinchGesture: public QPinchGesture
{
public:
	 ~MyQPinchGesture() { callbackQPinchGesture_DestroyQPinchGesture(this); };
	void childEvent(QChildEvent * event) { callbackQGesture_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGesture_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGesture_CustomEvent(this, event); };
	void deleteLater() { callbackQGesture_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGesture_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGesture_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGesture_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGesture_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGesture_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGesture_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGesture_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QPinchGesture*)
Q_DECLARE_METATYPE(MyQPinchGesture*)

int QPinchGesture_QPinchGesture_QRegisterMetaType(){qRegisterMetaType<QPinchGesture*>(); return qRegisterMetaType<MyQPinchGesture*>();}

void* QPinchGesture_CenterPoint(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QPinchGesture*>(ptr)->centerPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

long long QPinchGesture_ChangeFlags(void* ptr)
{
	return static_cast<QPinchGesture*>(ptr)->changeFlags();
}

void* QPinchGesture_LastCenterPoint(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QPinchGesture*>(ptr)->lastCenterPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

double QPinchGesture_LastRotationAngle(void* ptr)
{
	return static_cast<QPinchGesture*>(ptr)->lastRotationAngle();
}

double QPinchGesture_LastScaleFactor(void* ptr)
{
	return static_cast<QPinchGesture*>(ptr)->lastScaleFactor();
}

double QPinchGesture_RotationAngle(void* ptr)
{
	return static_cast<QPinchGesture*>(ptr)->rotationAngle();
}

double QPinchGesture_ScaleFactor(void* ptr)
{
	return static_cast<QPinchGesture*>(ptr)->scaleFactor();
}

void QPinchGesture_SetCenterPoint(void* ptr, void* value)
{
	static_cast<QPinchGesture*>(ptr)->setCenterPoint(*static_cast<QPointF*>(value));
}

void QPinchGesture_SetChangeFlags(void* ptr, long long value)
{
	static_cast<QPinchGesture*>(ptr)->setChangeFlags(static_cast<QPinchGesture::ChangeFlag>(value));
}

void QPinchGesture_SetLastCenterPoint(void* ptr, void* value)
{
	static_cast<QPinchGesture*>(ptr)->setLastCenterPoint(*static_cast<QPointF*>(value));
}

void QPinchGesture_SetLastRotationAngle(void* ptr, double value)
{
	static_cast<QPinchGesture*>(ptr)->setLastRotationAngle(value);
}

void QPinchGesture_SetLastScaleFactor(void* ptr, double value)
{
	static_cast<QPinchGesture*>(ptr)->setLastScaleFactor(value);
}

void QPinchGesture_SetRotationAngle(void* ptr, double value)
{
	static_cast<QPinchGesture*>(ptr)->setRotationAngle(value);
}

void QPinchGesture_SetScaleFactor(void* ptr, double value)
{
	static_cast<QPinchGesture*>(ptr)->setScaleFactor(value);
}

void QPinchGesture_SetStartCenterPoint(void* ptr, void* value)
{
	static_cast<QPinchGesture*>(ptr)->setStartCenterPoint(*static_cast<QPointF*>(value));
}

void QPinchGesture_SetTotalChangeFlags(void* ptr, long long value)
{
	static_cast<QPinchGesture*>(ptr)->setTotalChangeFlags(static_cast<QPinchGesture::ChangeFlag>(value));
}

void QPinchGesture_SetTotalRotationAngle(void* ptr, double value)
{
	static_cast<QPinchGesture*>(ptr)->setTotalRotationAngle(value);
}

void QPinchGesture_SetTotalScaleFactor(void* ptr, double value)
{
	static_cast<QPinchGesture*>(ptr)->setTotalScaleFactor(value);
}

void* QPinchGesture_StartCenterPoint(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QPinchGesture*>(ptr)->startCenterPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

long long QPinchGesture_TotalChangeFlags(void* ptr)
{
	return static_cast<QPinchGesture*>(ptr)->totalChangeFlags();
}

double QPinchGesture_TotalRotationAngle(void* ptr)
{
	return static_cast<QPinchGesture*>(ptr)->totalRotationAngle();
}

double QPinchGesture_TotalScaleFactor(void* ptr)
{
	return static_cast<QPinchGesture*>(ptr)->totalScaleFactor();
}

void QPinchGesture_DestroyQPinchGesture(void* ptr)
{
	static_cast<QPinchGesture*>(ptr)->~QPinchGesture();
}

void QPinchGesture_DestroyQPinchGestureDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQPlainTextDocumentLayout: public QPlainTextDocumentLayout
{
public:
	MyQPlainTextDocumentLayout(QTextDocument *document) : QPlainTextDocumentLayout(document) {QPlainTextDocumentLayout_QPlainTextDocumentLayout_QRegisterMetaType();};
	QRectF blockBoundingRect(const QTextBlock & block) const { return *static_cast<QRectF*>(callbackQPlainTextDocumentLayout_BlockBoundingRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QTextBlock*>(&block))); };
	void documentChanged(int from, int charsRemoved, int charsAdded) { callbackQPlainTextDocumentLayout_DocumentChanged(this, from, charsRemoved, charsAdded); };
	QSizeF documentSize() const { return *static_cast<QSizeF*>(callbackQPlainTextDocumentLayout_DocumentSize(const_cast<void*>(static_cast<const void*>(this)))); };
	QRectF frameBoundingRect(QTextFrame * vqt) const { return *static_cast<QRectF*>(callbackQPlainTextDocumentLayout_FrameBoundingRect(const_cast<void*>(static_cast<const void*>(this)), vqt)); };
	int hitTest(const QPointF & vqp, Qt::HitTestAccuracy vqt) const { return callbackQPlainTextDocumentLayout_HitTest(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&vqp), vqt); };
	int pageCount() const { return callbackQPlainTextDocumentLayout_PageCount(const_cast<void*>(static_cast<const void*>(this))); };
	 ~MyQPlainTextDocumentLayout() { callbackQPlainTextDocumentLayout_DestroyQPlainTextDocumentLayout(this); };
	void Signal_DocumentSizeChanged(const QSizeF & newSize) { callbackQPlainTextDocumentLayout_DocumentSizeChanged(this, const_cast<QSizeF*>(&newSize)); };
	void Signal_PageCountChanged(int newPages) { callbackQPlainTextDocumentLayout_PageCountChanged(this, newPages); };
	void Signal_Update(const QRectF & rect) { callbackQPlainTextDocumentLayout_Update(this, const_cast<QRectF*>(&rect)); };
	void Signal_UpdateBlock(const QTextBlock & block) { callbackQPlainTextDocumentLayout_UpdateBlock(this, const_cast<QTextBlock*>(&block)); };
	void childEvent(QChildEvent * event) { callbackQPlainTextDocumentLayout_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQPlainTextDocumentLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQPlainTextDocumentLayout_CustomEvent(this, event); };
	void deleteLater() { callbackQPlainTextDocumentLayout_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQPlainTextDocumentLayout_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQPlainTextDocumentLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQPlainTextDocumentLayout_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQPlainTextDocumentLayout_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQPlainTextDocumentLayout_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQPlainTextDocumentLayout_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQPlainTextDocumentLayout_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QPlainTextDocumentLayout*)
Q_DECLARE_METATYPE(MyQPlainTextDocumentLayout*)

int QPlainTextDocumentLayout_QPlainTextDocumentLayout_QRegisterMetaType(){qRegisterMetaType<QPlainTextDocumentLayout*>(); return qRegisterMetaType<MyQPlainTextDocumentLayout*>();}

void* QPlainTextDocumentLayout_NewQPlainTextDocumentLayout(void* document)
{
	return new MyQPlainTextDocumentLayout(static_cast<QTextDocument*>(document));
}

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

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

int QPlainTextDocumentLayout_CursorWidth(void* ptr)
{
	return static_cast<QPlainTextDocumentLayout*>(ptr)->cursorWidth();
}

void QPlainTextDocumentLayout_DocumentChanged(void* ptr, int from, int charsRemoved, int charsAdded)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->documentChanged(from, charsRemoved, charsAdded);
}

void QPlainTextDocumentLayout_DocumentChangedDefault(void* ptr, int from, int charsRemoved, int charsAdded)
{
		static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::documentChanged(from, charsRemoved, charsAdded);
}

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

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

void QPlainTextDocumentLayout_EnsureBlockLayout(void* ptr, void* block)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->ensureBlockLayout(*static_cast<QTextBlock*>(block));
}

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

void* QPlainTextDocumentLayout_FrameBoundingRectDefault(void* ptr, void* vqt)
{
		return ({ QRectF tmpValue = static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::frameBoundingRect(static_cast<QTextFrame*>(vqt)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

int QPlainTextDocumentLayout_HitTest(void* ptr, void* vqp, long long vqt)
{
	return static_cast<QPlainTextDocumentLayout*>(ptr)->hitTest(*static_cast<QPointF*>(vqp), static_cast<Qt::HitTestAccuracy>(vqt));
}

int QPlainTextDocumentLayout_HitTestDefault(void* ptr, void* vqp, long long vqt)
{
		return static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::hitTest(*static_cast<QPointF*>(vqp), static_cast<Qt::HitTestAccuracy>(vqt));
}

int QPlainTextDocumentLayout_PageCount(void* ptr)
{
	return static_cast<QPlainTextDocumentLayout*>(ptr)->pageCount();
}

int QPlainTextDocumentLayout_PageCountDefault(void* ptr)
{
		return static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::pageCount();
}

void QPlainTextDocumentLayout_RequestUpdate(void* ptr)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->requestUpdate();
}

void QPlainTextDocumentLayout_SetCursorWidth(void* ptr, int width)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->setCursorWidth(width);
}

void QPlainTextDocumentLayout_DestroyQPlainTextDocumentLayout(void* ptr)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->~QPlainTextDocumentLayout();
}

void QPlainTextDocumentLayout_DestroyQPlainTextDocumentLayoutDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QPlainTextDocumentLayout___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QPlainTextDocumentLayout___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QPlainTextDocumentLayout___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QPlainTextDocumentLayout___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QPlainTextDocumentLayout___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QPlainTextDocumentLayout___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QPlainTextDocumentLayout___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

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

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

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

void QPlainTextDocumentLayout_DeleteLaterDefault(void* ptr)
{
		static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::deleteLater();
}

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

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

char QPlainTextDocumentLayout_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQPlainTextEdit: public QPlainTextEdit
{
public:
	MyQPlainTextEdit(QWidget *parent = Q_NULLPTR) : QPlainTextEdit(parent) {QPlainTextEdit_QPlainTextEdit_QRegisterMetaType();};
	MyQPlainTextEdit(const QString &text, QWidget *parent = Q_NULLPTR) : QPlainTextEdit(text, parent) {QPlainTextEdit_QPlainTextEdit_QRegisterMetaType();};
	void appendHtml(const QString & html) { QByteArray* t950a39 = new QByteArray(html.toUtf8()); QtWidgets_PackedString htmlPacked = { const_cast<char*>(t950a39->prepend("WHITESPACE").constData()+10), t950a39->size()-10, t950a39 };callbackQPlainTextEdit_AppendHtml(this, htmlPacked); };
	void appendPlainText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQPlainTextEdit_AppendPlainText(this, textPacked); };
	void Signal_BlockCountChanged(int newBlockCount) { callbackQPlainTextEdit_BlockCountChanged(this, newBlockCount); };
	bool canInsertFromMimeData(const QMimeData * source) const { return callbackQPlainTextEdit_CanInsertFromMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(source)) != 0; };
	void centerCursor() { callbackQPlainTextEdit_CenterCursor(this); };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void clear() { callbackQPlainTextEdit_Clear(this); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void copy() { callbackQPlainTextEdit_Copy(this); };
	void Signal_CopyAvailable(bool yes) { callbackQPlainTextEdit_CopyAvailable(this, yes); };
	QMimeData * createMimeDataFromSelection() const { return static_cast<QMimeData*>(callbackQPlainTextEdit_CreateMimeDataFromSelection(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_CursorPositionChanged() { callbackQPlainTextEdit_CursorPositionChanged(this); };
	void cut() { callbackQPlainTextEdit_Cut(this); };
	void dragEnterEvent(QDragEnterEvent * e) { callbackQWidget_DragEnterEvent(this, e); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQWidget_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQWidget_DragMoveEvent(this, e); };
	void dropEvent(QDropEvent * e) { callbackQWidget_DropEvent(this, e); };
	void focusInEvent(QFocusEvent * e) { callbackQWidget_FocusInEvent(this, e); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * e) { callbackQWidget_FocusOutEvent(this, e); };
	void inputMethodEvent(QInputMethodEvent * e) { callbackQWidget_InputMethodEvent(this, e); };
	QVariant inputMethodQuery(Qt::InputMethodQuery property) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), property)); };
	void insertFromMimeData(const QMimeData * source) { callbackQPlainTextEdit_InsertFromMimeData(this, const_cast<QMimeData*>(source)); };
	void insertPlainText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQPlainTextEdit_InsertPlainText(this, textPacked); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQWidget_KeyReleaseEvent(this, e); };
	QVariant loadResource(int ty, const QUrl & name) { return *static_cast<QVariant*>(callbackQPlainTextEdit_LoadResource(this, ty, const_cast<QUrl*>(&name))); };
	void Signal_ModificationChanged(bool changed) { callbackQPlainTextEdit_ModificationChanged(this, changed); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQWidget_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQWidget_PaintEvent(this, e); };
	void paste() { callbackQPlainTextEdit_Paste(this); };
	void redo() { callbackQPlainTextEdit_Redo(this); };
	void Signal_RedoAvailable(bool available) { callbackQPlainTextEdit_RedoAvailable(this, available); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void selectAll() { callbackQPlainTextEdit_SelectAll(this); };
	void Signal_SelectionChanged() { callbackQPlainTextEdit_SelectionChanged(this); };
	void setPlainText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQPlainTextEdit_SetPlainText(this, textPacked); };
	void showEvent(QShowEvent * vqs) { callbackQWidget_ShowEvent(this, vqs); };
	void Signal_TextChanged() { callbackQPlainTextEdit_TextChanged(this); };
	void undo() { callbackQPlainTextEdit_Undo(this); };
	void Signal_UndoAvailable(bool available) { callbackQPlainTextEdit_UndoAvailable(this, available); };
	void Signal_UpdateRequest(const QRect & rect, int dy) { callbackQPlainTextEdit_UpdateRequest(this, const_cast<QRect*>(&rect), dy); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void zoomIn(int ran) { callbackQPlainTextEdit_ZoomIn(this, ran); };
	void zoomOut(int ran) { callbackQPlainTextEdit_ZoomOut(this, ran); };
	 ~MyQPlainTextEdit() { callbackQPlainTextEdit_DestroyQPlainTextEdit(this); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QPlainTextEdit*)
Q_DECLARE_METATYPE(MyQPlainTextEdit*)

int QPlainTextEdit_QPlainTextEdit_QRegisterMetaType(){qRegisterMetaType<QPlainTextEdit*>(); return qRegisterMetaType<MyQPlainTextEdit*>();}

void* QPlainTextEdit_NewQPlainTextEdit(void* parent)
{
		return new MyQPlainTextEdit(static_cast<QWidget*>(parent));
}

void* QPlainTextEdit_NewQPlainTextEdit2(struct QtWidgets_PackedString text, void* parent)
{
		return new MyQPlainTextEdit(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(parent));
}

struct QtWidgets_PackedString QPlainTextEdit_AnchorAt(void* ptr, void* pos)
{
	return ({ QByteArray* t8a0984 = new QByteArray(static_cast<QPlainTextEdit*>(ptr)->anchorAt(*static_cast<QPoint*>(pos)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t8a0984->prepend("WHITESPACE").constData()+10), t8a0984->size()-10, t8a0984 }; });
}

void QPlainTextEdit_AppendHtml(void* ptr, struct QtWidgets_PackedString html)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "appendHtml", Q_ARG(const QString, QString::fromUtf8(html.data, html.len)));
}

void QPlainTextEdit_AppendHtmlDefault(void* ptr, struct QtWidgets_PackedString html)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::appendHtml(QString::fromUtf8(html.data, html.len));
}

void QPlainTextEdit_AppendPlainText(void* ptr, struct QtWidgets_PackedString text)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "appendPlainText", Q_ARG(const QString, QString::fromUtf8(text.data, text.len)));
}

void QPlainTextEdit_AppendPlainTextDefault(void* ptr, struct QtWidgets_PackedString text)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::appendPlainText(QString::fromUtf8(text.data, text.len));
}

char QPlainTextEdit_BackgroundVisible(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->backgroundVisible();
}

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

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

int QPlainTextEdit_BlockCount(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->blockCount();
}

void QPlainTextEdit_ConnectBlockCountChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)(int)>(&QPlainTextEdit::blockCountChanged), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)(int)>(&MyQPlainTextEdit::Signal_BlockCountChanged), static_cast<Qt::ConnectionType>(t));
}

void QPlainTextEdit_DisconnectBlockCountChanged(void* ptr)
{
	QObject::disconnect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)(int)>(&QPlainTextEdit::blockCountChanged), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)(int)>(&MyQPlainTextEdit::Signal_BlockCountChanged));
}

void QPlainTextEdit_BlockCountChanged(void* ptr, int newBlockCount)
{
	static_cast<QPlainTextEdit*>(ptr)->blockCountChanged(newBlockCount);
}

char QPlainTextEdit_CanInsertFromMimeData(void* ptr, void* source)
{
	return static_cast<QPlainTextEdit*>(ptr)->canInsertFromMimeData(static_cast<QMimeData*>(source));
}

char QPlainTextEdit_CanInsertFromMimeDataDefault(void* ptr, void* source)
{
		return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::canInsertFromMimeData(static_cast<QMimeData*>(source));
}

char QPlainTextEdit_CanPaste(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->canPaste();
}

void QPlainTextEdit_CenterCursor(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "centerCursor");
}

void QPlainTextEdit_CenterCursorDefault(void* ptr)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::centerCursor();
}

char QPlainTextEdit_CenterOnScroll(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->centerOnScroll();
}

void QPlainTextEdit_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "clear");
}

void QPlainTextEdit_ClearDefault(void* ptr)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::clear();
}

void* QPlainTextEdit_ContentOffset(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QPlainTextEdit*>(ptr)->contentOffset(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QPlainTextEdit_Copy(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "copy");
}

void QPlainTextEdit_CopyDefault(void* ptr)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::copy();
}

void QPlainTextEdit_ConnectCopyAvailable(void* ptr, long long t)
{
	QObject::connect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)(bool)>(&QPlainTextEdit::copyAvailable), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)(bool)>(&MyQPlainTextEdit::Signal_CopyAvailable), static_cast<Qt::ConnectionType>(t));
}

void QPlainTextEdit_DisconnectCopyAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)(bool)>(&QPlainTextEdit::copyAvailable), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)(bool)>(&MyQPlainTextEdit::Signal_CopyAvailable));
}

void QPlainTextEdit_CopyAvailable(void* ptr, char yes)
{
	static_cast<QPlainTextEdit*>(ptr)->copyAvailable(yes != 0);
}

void* QPlainTextEdit_CreateMimeDataFromSelection(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->createMimeDataFromSelection();
}

void* QPlainTextEdit_CreateMimeDataFromSelectionDefault(void* ptr)
{
		return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::createMimeDataFromSelection();
}

void* QPlainTextEdit_CreateStandardContextMenu(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->createStandardContextMenu();
}

void* QPlainTextEdit_CreateStandardContextMenu2(void* ptr, void* position)
{
	return static_cast<QPlainTextEdit*>(ptr)->createStandardContextMenu(*static_cast<QPoint*>(position));
}

void* QPlainTextEdit_CurrentCharFormat(void* ptr)
{
	return new QTextCharFormat(static_cast<QPlainTextEdit*>(ptr)->currentCharFormat());
}

void* QPlainTextEdit_CursorForPosition(void* ptr, void* pos)
{
	return new QTextCursor(static_cast<QPlainTextEdit*>(ptr)->cursorForPosition(*static_cast<QPoint*>(pos)));
}

void QPlainTextEdit_ConnectCursorPositionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)()>(&QPlainTextEdit::cursorPositionChanged), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)()>(&MyQPlainTextEdit::Signal_CursorPositionChanged), static_cast<Qt::ConnectionType>(t));
}

void QPlainTextEdit_DisconnectCursorPositionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)()>(&QPlainTextEdit::cursorPositionChanged), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)()>(&MyQPlainTextEdit::Signal_CursorPositionChanged));
}

void QPlainTextEdit_CursorPositionChanged(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->cursorPositionChanged();
}

void* QPlainTextEdit_CursorRect(void* ptr, void* cursor)
{
	return ({ QRect tmpValue = static_cast<QPlainTextEdit*>(ptr)->cursorRect(*static_cast<QTextCursor*>(cursor)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPlainTextEdit_CursorRect2(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QPlainTextEdit*>(ptr)->cursorRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

int QPlainTextEdit_CursorWidth(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->cursorWidth();
}

void QPlainTextEdit_Cut(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "cut");
}

void QPlainTextEdit_CutDefault(void* ptr)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::cut();
}

void* QPlainTextEdit_Document(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->document();
}

struct QtWidgets_PackedString QPlainTextEdit_DocumentTitle(void* ptr)
{
	return ({ QByteArray* tba0a66 = new QByteArray(static_cast<QPlainTextEdit*>(ptr)->documentTitle().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tba0a66->prepend("WHITESPACE").constData()+10), tba0a66->size()-10, tba0a66 }; });
}

void QPlainTextEdit_EnsureCursorVisible(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->ensureCursorVisible();
}

char QPlainTextEdit_Find(void* ptr, struct QtWidgets_PackedString exp, long long options)
{
	return static_cast<QPlainTextEdit*>(ptr)->find(QString::fromUtf8(exp.data, exp.len), static_cast<QTextDocument::FindFlag>(options));
}

char QPlainTextEdit_Find2(void* ptr, void* exp, long long options)
{
	return static_cast<QPlainTextEdit*>(ptr)->find(*static_cast<QRegExp*>(exp), static_cast<QTextDocument::FindFlag>(options));
}

char QPlainTextEdit_Find3(void* ptr, void* exp, long long options)
{
	return static_cast<QPlainTextEdit*>(ptr)->find(*static_cast<QRegularExpression*>(exp), static_cast<QTextDocument::FindFlag>(options));
}

void* QPlainTextEdit_FirstVisibleBlock(void* ptr)
{
	return new QTextBlock(static_cast<QPlainTextEdit*>(ptr)->firstVisibleBlock());
}

void QPlainTextEdit_InsertFromMimeData(void* ptr, void* source)
{
	static_cast<QPlainTextEdit*>(ptr)->insertFromMimeData(static_cast<QMimeData*>(source));
}

void QPlainTextEdit_InsertFromMimeDataDefault(void* ptr, void* source)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::insertFromMimeData(static_cast<QMimeData*>(source));
}

void QPlainTextEdit_InsertPlainText(void* ptr, struct QtWidgets_PackedString text)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "insertPlainText", Q_ARG(const QString, QString::fromUtf8(text.data, text.len)));
}

void QPlainTextEdit_InsertPlainTextDefault(void* ptr, struct QtWidgets_PackedString text)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::insertPlainText(QString::fromUtf8(text.data, text.len));
}

char QPlainTextEdit_IsReadOnly(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->isReadOnly();
}

char QPlainTextEdit_IsUndoRedoEnabled(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->isUndoRedoEnabled();
}

long long QPlainTextEdit_LineWrapMode(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->lineWrapMode();
}

void* QPlainTextEdit_LoadResource(void* ptr, int ty, void* name)
{
	return new QVariant(static_cast<QPlainTextEdit*>(ptr)->loadResource(ty, *static_cast<QUrl*>(name)));
}

void* QPlainTextEdit_LoadResourceDefault(void* ptr, int ty, void* name)
{
		return new QVariant(static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::loadResource(ty, *static_cast<QUrl*>(name)));
}

int QPlainTextEdit_MaximumBlockCount(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->maximumBlockCount();
}

void QPlainTextEdit_MergeCurrentCharFormat(void* ptr, void* modifier)
{
	static_cast<QPlainTextEdit*>(ptr)->mergeCurrentCharFormat(*static_cast<QTextCharFormat*>(modifier));
}

void QPlainTextEdit_ConnectModificationChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)(bool)>(&QPlainTextEdit::modificationChanged), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)(bool)>(&MyQPlainTextEdit::Signal_ModificationChanged), static_cast<Qt::ConnectionType>(t));
}

void QPlainTextEdit_DisconnectModificationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)(bool)>(&QPlainTextEdit::modificationChanged), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)(bool)>(&MyQPlainTextEdit::Signal_ModificationChanged));
}

void QPlainTextEdit_ModificationChanged(void* ptr, char changed)
{
	static_cast<QPlainTextEdit*>(ptr)->modificationChanged(changed != 0);
}

void QPlainTextEdit_MoveCursor(void* ptr, long long operation, long long mode)
{
	static_cast<QPlainTextEdit*>(ptr)->moveCursor(static_cast<QTextCursor::MoveOperation>(operation), static_cast<QTextCursor::MoveMode>(mode));
}

char QPlainTextEdit_OverwriteMode(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->overwriteMode();
}

void QPlainTextEdit_Paste(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "paste");
}

void QPlainTextEdit_PasteDefault(void* ptr)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::paste();
}

struct QtWidgets_PackedString QPlainTextEdit_PlaceholderText(void* ptr)
{
	return ({ QByteArray* tb4d3fc = new QByteArray(static_cast<QPlainTextEdit*>(ptr)->placeholderText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tb4d3fc->prepend("WHITESPACE").constData()+10), tb4d3fc->size()-10, tb4d3fc }; });
}

void QPlainTextEdit_Print(void* ptr, void* printer)
{
#ifndef Q_OS_IOS
	static_cast<QPlainTextEdit*>(ptr)->print(static_cast<QPagedPaintDevice*>(printer));
#endif
}

void QPlainTextEdit_Redo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "redo");
}

void QPlainTextEdit_RedoDefault(void* ptr)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::redo();
}

void QPlainTextEdit_ConnectRedoAvailable(void* ptr, long long t)
{
	QObject::connect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)(bool)>(&QPlainTextEdit::redoAvailable), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)(bool)>(&MyQPlainTextEdit::Signal_RedoAvailable), static_cast<Qt::ConnectionType>(t));
}

void QPlainTextEdit_DisconnectRedoAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)(bool)>(&QPlainTextEdit::redoAvailable), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)(bool)>(&MyQPlainTextEdit::Signal_RedoAvailable));
}

void QPlainTextEdit_RedoAvailable(void* ptr, char available)
{
	static_cast<QPlainTextEdit*>(ptr)->redoAvailable(available != 0);
}

void QPlainTextEdit_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "selectAll");
}

void QPlainTextEdit_SelectAllDefault(void* ptr)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::selectAll();
}

void QPlainTextEdit_ConnectSelectionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)()>(&QPlainTextEdit::selectionChanged), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)()>(&MyQPlainTextEdit::Signal_SelectionChanged), static_cast<Qt::ConnectionType>(t));
}

void QPlainTextEdit_DisconnectSelectionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)()>(&QPlainTextEdit::selectionChanged), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)()>(&MyQPlainTextEdit::Signal_SelectionChanged));
}

void QPlainTextEdit_SelectionChanged(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->selectionChanged();
}

void QPlainTextEdit_SetBackgroundVisible(void* ptr, char visible)
{
	static_cast<QPlainTextEdit*>(ptr)->setBackgroundVisible(visible != 0);
}

void QPlainTextEdit_SetCenterOnScroll(void* ptr, char enabled)
{
	static_cast<QPlainTextEdit*>(ptr)->setCenterOnScroll(enabled != 0);
}

void QPlainTextEdit_SetCurrentCharFormat(void* ptr, void* format)
{
	static_cast<QPlainTextEdit*>(ptr)->setCurrentCharFormat(*static_cast<QTextCharFormat*>(format));
}

void QPlainTextEdit_SetCursorWidth(void* ptr, int width)
{
	static_cast<QPlainTextEdit*>(ptr)->setCursorWidth(width);
}

void QPlainTextEdit_SetDocument(void* ptr, void* document)
{
	static_cast<QPlainTextEdit*>(ptr)->setDocument(static_cast<QTextDocument*>(document));
}

void QPlainTextEdit_SetDocumentTitle(void* ptr, struct QtWidgets_PackedString title)
{
	static_cast<QPlainTextEdit*>(ptr)->setDocumentTitle(QString::fromUtf8(title.data, title.len));
}

void QPlainTextEdit_SetLineWrapMode(void* ptr, long long mode)
{
	static_cast<QPlainTextEdit*>(ptr)->setLineWrapMode(static_cast<QPlainTextEdit::LineWrapMode>(mode));
}

void QPlainTextEdit_SetMaximumBlockCount(void* ptr, int maximum)
{
	static_cast<QPlainTextEdit*>(ptr)->setMaximumBlockCount(maximum);
}

void QPlainTextEdit_SetOverwriteMode(void* ptr, char overwrite)
{
	static_cast<QPlainTextEdit*>(ptr)->setOverwriteMode(overwrite != 0);
}

void QPlainTextEdit_SetPlaceholderText(void* ptr, struct QtWidgets_PackedString placeholderText)
{
	static_cast<QPlainTextEdit*>(ptr)->setPlaceholderText(QString::fromUtf8(placeholderText.data, placeholderText.len));
}

void QPlainTextEdit_SetPlainText(void* ptr, struct QtWidgets_PackedString text)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setPlainText", Q_ARG(const QString, QString::fromUtf8(text.data, text.len)));
}

void QPlainTextEdit_SetPlainTextDefault(void* ptr, struct QtWidgets_PackedString text)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setPlainText(QString::fromUtf8(text.data, text.len));
}

void QPlainTextEdit_SetReadOnly(void* ptr, char ro)
{
	static_cast<QPlainTextEdit*>(ptr)->setReadOnly(ro != 0);
}

void QPlainTextEdit_SetTabChangesFocus(void* ptr, char b)
{
	static_cast<QPlainTextEdit*>(ptr)->setTabChangesFocus(b != 0);
}

void QPlainTextEdit_SetTabStopDistance(void* ptr, double distance)
{
	static_cast<QPlainTextEdit*>(ptr)->setTabStopDistance(distance);
}

void QPlainTextEdit_SetTabStopWidth(void* ptr, int width)
{
	static_cast<QPlainTextEdit*>(ptr)->setTabStopWidth(width);
}

void QPlainTextEdit_SetTextCursor(void* ptr, void* cursor)
{
	static_cast<QPlainTextEdit*>(ptr)->setTextCursor(*static_cast<QTextCursor*>(cursor));
}

void QPlainTextEdit_SetTextInteractionFlags(void* ptr, long long flags)
{
	static_cast<QPlainTextEdit*>(ptr)->setTextInteractionFlags(static_cast<Qt::TextInteractionFlag>(flags));
}

void QPlainTextEdit_SetUndoRedoEnabled(void* ptr, char enable)
{
	static_cast<QPlainTextEdit*>(ptr)->setUndoRedoEnabled(enable != 0);
}

void QPlainTextEdit_SetWordWrapMode(void* ptr, long long policy)
{
	static_cast<QPlainTextEdit*>(ptr)->setWordWrapMode(static_cast<QTextOption::WrapMode>(policy));
}

char QPlainTextEdit_TabChangesFocus(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->tabChangesFocus();
}

double QPlainTextEdit_TabStopDistance(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->tabStopDistance();
}

int QPlainTextEdit_TabStopWidth(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->tabStopWidth();
}

void QPlainTextEdit_ConnectTextChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)()>(&QPlainTextEdit::textChanged), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)()>(&MyQPlainTextEdit::Signal_TextChanged), static_cast<Qt::ConnectionType>(t));
}

void QPlainTextEdit_DisconnectTextChanged(void* ptr)
{
	QObject::disconnect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)()>(&QPlainTextEdit::textChanged), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)()>(&MyQPlainTextEdit::Signal_TextChanged));
}

void QPlainTextEdit_TextChanged(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->textChanged();
}

void* QPlainTextEdit_TextCursor(void* ptr)
{
	return new QTextCursor(static_cast<QPlainTextEdit*>(ptr)->textCursor());
}

long long QPlainTextEdit_TextInteractionFlags(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->textInteractionFlags();
}

struct QtWidgets_PackedString QPlainTextEdit_ToPlainText(void* ptr)
{
	return ({ QByteArray* t3c8ca8 = new QByteArray(static_cast<QPlainTextEdit*>(ptr)->toPlainText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t3c8ca8->prepend("WHITESPACE").constData()+10), t3c8ca8->size()-10, t3c8ca8 }; });
}

void QPlainTextEdit_Undo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "undo");
}

void QPlainTextEdit_UndoDefault(void* ptr)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::undo();
}

void QPlainTextEdit_ConnectUndoAvailable(void* ptr, long long t)
{
	QObject::connect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)(bool)>(&QPlainTextEdit::undoAvailable), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)(bool)>(&MyQPlainTextEdit::Signal_UndoAvailable), static_cast<Qt::ConnectionType>(t));
}

void QPlainTextEdit_DisconnectUndoAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)(bool)>(&QPlainTextEdit::undoAvailable), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)(bool)>(&MyQPlainTextEdit::Signal_UndoAvailable));
}

void QPlainTextEdit_UndoAvailable(void* ptr, char available)
{
	static_cast<QPlainTextEdit*>(ptr)->undoAvailable(available != 0);
}

void QPlainTextEdit_ConnectUpdateRequest(void* ptr, long long t)
{
	QObject::connect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)(const QRect &, int)>(&QPlainTextEdit::updateRequest), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)(const QRect &, int)>(&MyQPlainTextEdit::Signal_UpdateRequest), static_cast<Qt::ConnectionType>(t));
}

void QPlainTextEdit_DisconnectUpdateRequest(void* ptr)
{
	QObject::disconnect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)(const QRect &, int)>(&QPlainTextEdit::updateRequest), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)(const QRect &, int)>(&MyQPlainTextEdit::Signal_UpdateRequest));
}

void QPlainTextEdit_UpdateRequest(void* ptr, void* rect, int dy)
{
	static_cast<QPlainTextEdit*>(ptr)->updateRequest(*static_cast<QRect*>(rect), dy);
}

long long QPlainTextEdit_WordWrapMode(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->wordWrapMode();
}

void QPlainTextEdit_ZoomIn(void* ptr, int ran)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "zoomIn", Q_ARG(int, ran));
}

void QPlainTextEdit_ZoomInDefault(void* ptr, int ran)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::zoomIn(ran);
}

void QPlainTextEdit_ZoomOut(void* ptr, int ran)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "zoomOut", Q_ARG(int, ran));
}

void QPlainTextEdit_ZoomOutDefault(void* ptr, int ran)
{
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::zoomOut(ran);
}

void QPlainTextEdit_DestroyQPlainTextEdit(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->~QPlainTextEdit();
}

void QPlainTextEdit_DestroyQPlainTextEditDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQProgressBar: public QProgressBar
{
public:
	MyQProgressBar(QWidget *parent = Q_NULLPTR) : QProgressBar(parent) {QProgressBar_QProgressBar_QRegisterMetaType();};
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
	void reset() { callbackQProgressBar_Reset(this); };
	void setMaximum(int maximum) { callbackQProgressBar_SetMaximum(this, maximum); };
	void setMinimum(int minimum) { callbackQProgressBar_SetMinimum(this, minimum); };
	void setOrientation(Qt::Orientation vqt) { callbackQProgressBar_SetOrientation(this, vqt); };
	void setRange(int minimum, int maximum) { callbackQProgressBar_SetRange(this, minimum, maximum); };
	void setValue(int value) { callbackQProgressBar_SetValue(this, value); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QString text() const { return ({ QtWidgets_PackedString tempVal = callbackQProgressBar_Text(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void Signal_ValueChanged(int value) { callbackQProgressBar_ValueChanged(this, value); };
	 ~MyQProgressBar() { callbackQProgressBar_DestroyQProgressBar(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QProgressBar*)
Q_DECLARE_METATYPE(MyQProgressBar*)

int QProgressBar_QProgressBar_QRegisterMetaType(){qRegisterMetaType<QProgressBar*>(); return qRegisterMetaType<MyQProgressBar*>();}

void* QProgressBar_NewQProgressBar(void* parent)
{
		return new MyQProgressBar(static_cast<QWidget*>(parent));
}

long long QProgressBar_Alignment(void* ptr)
{
	return static_cast<QProgressBar*>(ptr)->alignment();
}

struct QtWidgets_PackedString QProgressBar_Format(void* ptr)
{
	return ({ QByteArray* tfbdd88 = new QByteArray(static_cast<QProgressBar*>(ptr)->format().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tfbdd88->prepend("WHITESPACE").constData()+10), tfbdd88->size()-10, tfbdd88 }; });
}

void QProgressBar_InitStyleOption(void* ptr, void* option)
{
	static_cast<QProgressBar*>(ptr)->initStyleOption(static_cast<QStyleOptionProgressBar*>(option));
}

char QProgressBar_InvertedAppearance(void* ptr)
{
	return static_cast<QProgressBar*>(ptr)->invertedAppearance();
}

char QProgressBar_IsTextVisible(void* ptr)
{
	return static_cast<QProgressBar*>(ptr)->isTextVisible();
}

int QProgressBar_Maximum(void* ptr)
{
	return static_cast<QProgressBar*>(ptr)->maximum();
}

int QProgressBar_Minimum(void* ptr)
{
	return static_cast<QProgressBar*>(ptr)->minimum();
}

long long QProgressBar_Orientation(void* ptr)
{
	return static_cast<QProgressBar*>(ptr)->orientation();
}

void QProgressBar_Reset(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "reset");
}

void QProgressBar_ResetDefault(void* ptr)
{
		static_cast<QProgressBar*>(ptr)->QProgressBar::reset();
}

void QProgressBar_ResetFormat(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->resetFormat();
}

void QProgressBar_SetAlignment(void* ptr, long long alignment)
{
	static_cast<QProgressBar*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}

void QProgressBar_SetFormat(void* ptr, struct QtWidgets_PackedString format)
{
	static_cast<QProgressBar*>(ptr)->setFormat(QString::fromUtf8(format.data, format.len));
}

void QProgressBar_SetInvertedAppearance(void* ptr, char invert)
{
	static_cast<QProgressBar*>(ptr)->setInvertedAppearance(invert != 0);
}

void QProgressBar_SetMaximum(void* ptr, int maximum)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setMaximum", Q_ARG(int, maximum));
}

void QProgressBar_SetMaximumDefault(void* ptr, int maximum)
{
		static_cast<QProgressBar*>(ptr)->QProgressBar::setMaximum(maximum);
}

void QProgressBar_SetMinimum(void* ptr, int minimum)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setMinimum", Q_ARG(int, minimum));
}

void QProgressBar_SetMinimumDefault(void* ptr, int minimum)
{
		static_cast<QProgressBar*>(ptr)->QProgressBar::setMinimum(minimum);
}

void QProgressBar_SetOrientation(void* ptr, long long vqt)
{
	qRegisterMetaType<Qt::Orientation>();
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setOrientation", Q_ARG(Qt::Orientation, static_cast<Qt::Orientation>(vqt)));
}

void QProgressBar_SetOrientationDefault(void* ptr, long long vqt)
{
		static_cast<QProgressBar*>(ptr)->QProgressBar::setOrientation(static_cast<Qt::Orientation>(vqt));
}

void QProgressBar_SetRange(void* ptr, int minimum, int maximum)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setRange", Q_ARG(int, minimum), Q_ARG(int, maximum));
}

void QProgressBar_SetRangeDefault(void* ptr, int minimum, int maximum)
{
		static_cast<QProgressBar*>(ptr)->QProgressBar::setRange(minimum, maximum);
}

void QProgressBar_SetTextDirection(void* ptr, long long textDirection)
{
	static_cast<QProgressBar*>(ptr)->setTextDirection(static_cast<QProgressBar::Direction>(textDirection));
}

void QProgressBar_SetTextVisible(void* ptr, char visible)
{
	static_cast<QProgressBar*>(ptr)->setTextVisible(visible != 0);
}

void QProgressBar_SetValue(void* ptr, int value)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setValue", Q_ARG(int, value));
}

void QProgressBar_SetValueDefault(void* ptr, int value)
{
		static_cast<QProgressBar*>(ptr)->QProgressBar::setValue(value);
}

struct QtWidgets_PackedString QProgressBar_Text(void* ptr)
{
	return ({ QByteArray* tffaa7f = new QByteArray(static_cast<QProgressBar*>(ptr)->text().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tffaa7f->prepend("WHITESPACE").constData()+10), tffaa7f->size()-10, tffaa7f }; });
}

struct QtWidgets_PackedString QProgressBar_TextDefault(void* ptr)
{
		return ({ QByteArray* t6f1b9c = new QByteArray(static_cast<QProgressBar*>(ptr)->QProgressBar::text().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t6f1b9c->prepend("WHITESPACE").constData()+10), t6f1b9c->size()-10, t6f1b9c }; });
}

long long QProgressBar_TextDirection(void* ptr)
{
	return static_cast<QProgressBar*>(ptr)->textDirection();
}

int QProgressBar_Value(void* ptr)
{
	return static_cast<QProgressBar*>(ptr)->value();
}

void QProgressBar_ConnectValueChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QProgressBar*>(ptr), static_cast<void (QProgressBar::*)(int)>(&QProgressBar::valueChanged), static_cast<MyQProgressBar*>(ptr), static_cast<void (MyQProgressBar::*)(int)>(&MyQProgressBar::Signal_ValueChanged), static_cast<Qt::ConnectionType>(t));
}

void QProgressBar_DisconnectValueChanged(void* ptr)
{
	QObject::disconnect(static_cast<QProgressBar*>(ptr), static_cast<void (QProgressBar::*)(int)>(&QProgressBar::valueChanged), static_cast<MyQProgressBar*>(ptr), static_cast<void (MyQProgressBar::*)(int)>(&MyQProgressBar::Signal_ValueChanged));
}

void QProgressBar_ValueChanged(void* ptr, int value)
{
	static_cast<QProgressBar*>(ptr)->valueChanged(value);
}

void QProgressBar_DestroyQProgressBar(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->~QProgressBar();
}

void QProgressBar_DestroyQProgressBarDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQProgressDialog: public QProgressDialog
{
public:
	MyQProgressDialog(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QProgressDialog(parent, ff) {QProgressDialog_QProgressDialog_QRegisterMetaType();};
	MyQProgressDialog(const QString &labelText, const QString &cancelButtonText, int minimum, int maximum, QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QProgressDialog(labelText, cancelButtonText, minimum, maximum, parent, ff) {QProgressDialog_QProgressDialog_QRegisterMetaType();};
	void cancel() { callbackQProgressDialog_Cancel(this); };
	void Signal_Canceled() { callbackQProgressDialog_Canceled(this); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void closeEvent(QCloseEvent * e) { callbackQWidget_CloseEvent(this, e); };
	void forceShow() { callbackQProgressDialog_ForceShow(this); };
	void reset() { callbackQProgressDialog_Reset(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setCancelButtonText(const QString & cancelButtonText) { QByteArray* td2e1e2 = new QByteArray(cancelButtonText.toUtf8()); QtWidgets_PackedString cancelButtonTextPacked = { const_cast<char*>(td2e1e2->prepend("WHITESPACE").constData()+10), td2e1e2->size()-10, td2e1e2 };callbackQProgressDialog_SetCancelButtonText(this, cancelButtonTextPacked); };
	void setLabelText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQProgressDialog_SetLabelText(this, textPacked); };
	void setMaximum(int maximum) { callbackQProgressDialog_SetMaximum(this, maximum); };
	void setMinimum(int minimum) { callbackQProgressDialog_SetMinimum(this, minimum); };
	void setMinimumDuration(int ms) { callbackQProgressDialog_SetMinimumDuration(this, ms); };
	void setRange(int minimum, int maximum) { callbackQProgressDialog_SetRange(this, minimum, maximum); };
	void setValue(int progress) { callbackQProgressDialog_SetValue(this, progress); };
	void showEvent(QShowEvent * e) { callbackQWidget_ShowEvent(this, e); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQProgressDialog() { callbackQProgressDialog_DestroyQProgressDialog(this); };
	void accept() { callbackQDialog_Accept(this); };
	void Signal_Accepted() { callbackQDialog_Accepted(this); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	void done(int r) { callbackQDialog_Done(this, r); };
	bool eventFilter(QObject * o, QEvent * e) { return callbackQWidget_EventFilter(this, o, e) != 0; };
	int exec() { return callbackQDialog_Exec(this); };
	void Signal_Finished(int result) { callbackQDialog_Finished(this, result); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void reject() { callbackQDialog_Reject(this); };
	void Signal_Rejected() { callbackQDialog_Rejected(this); };
	void setVisible(bool visible) { callbackQDialog_SetVisible(this, visible); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QProgressDialog*)
Q_DECLARE_METATYPE(MyQProgressDialog*)

int QProgressDialog_QProgressDialog_QRegisterMetaType(){qRegisterMetaType<QProgressDialog*>(); return qRegisterMetaType<MyQProgressDialog*>();}

void* QProgressDialog_NewQProgressDialog(void* parent, long long ff)
{
		return new MyQProgressDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}

void* QProgressDialog_NewQProgressDialog2(struct QtWidgets_PackedString labelText, struct QtWidgets_PackedString cancelButtonText, int minimum, int maximum, void* parent, long long ff)
{
		return new MyQProgressDialog(QString::fromUtf8(labelText.data, labelText.len), QString::fromUtf8(cancelButtonText.data, cancelButtonText.len), minimum, maximum, static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}

char QProgressDialog_AutoClose(void* ptr)
{
	return static_cast<QProgressDialog*>(ptr)->autoClose();
}

char QProgressDialog_AutoReset(void* ptr)
{
	return static_cast<QProgressDialog*>(ptr)->autoReset();
}

void QProgressDialog_Cancel(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "cancel");
}

void QProgressDialog_CancelDefault(void* ptr)
{
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::cancel();
}

void QProgressDialog_ConnectCanceled(void* ptr, long long t)
{
	QObject::connect(static_cast<QProgressDialog*>(ptr), static_cast<void (QProgressDialog::*)()>(&QProgressDialog::canceled), static_cast<MyQProgressDialog*>(ptr), static_cast<void (MyQProgressDialog::*)()>(&MyQProgressDialog::Signal_Canceled), static_cast<Qt::ConnectionType>(t));
}

void QProgressDialog_DisconnectCanceled(void* ptr)
{
	QObject::disconnect(static_cast<QProgressDialog*>(ptr), static_cast<void (QProgressDialog::*)()>(&QProgressDialog::canceled), static_cast<MyQProgressDialog*>(ptr), static_cast<void (MyQProgressDialog::*)()>(&MyQProgressDialog::Signal_Canceled));
}

void QProgressDialog_Canceled(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->canceled();
}

void QProgressDialog_ForceShow(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "forceShow");
}

void QProgressDialog_ForceShowDefault(void* ptr)
{
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::forceShow();
}

struct QtWidgets_PackedString QProgressDialog_LabelText(void* ptr)
{
	return ({ QByteArray* t2a151b = new QByteArray(static_cast<QProgressDialog*>(ptr)->labelText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t2a151b->prepend("WHITESPACE").constData()+10), t2a151b->size()-10, t2a151b }; });
}

int QProgressDialog_Maximum(void* ptr)
{
	return static_cast<QProgressDialog*>(ptr)->maximum();
}

int QProgressDialog_Minimum(void* ptr)
{
	return static_cast<QProgressDialog*>(ptr)->minimum();
}

int QProgressDialog_MinimumDuration(void* ptr)
{
	return static_cast<QProgressDialog*>(ptr)->minimumDuration();
}

void QProgressDialog_Open(void* ptr, void* receiver, char* member)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(receiver))) {
		static_cast<QProgressDialog*>(ptr)->open(static_cast<QGraphicsObject*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(receiver))) {
		static_cast<QProgressDialog*>(ptr)->open(static_cast<QGraphicsWidget*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(receiver))) {
		static_cast<QProgressDialog*>(ptr)->open(static_cast<QLayout*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(receiver))) {
		static_cast<QProgressDialog*>(ptr)->open(static_cast<QWidget*>(receiver), const_cast<const char*>(member));
	} else {
		static_cast<QProgressDialog*>(ptr)->open(static_cast<QObject*>(receiver), const_cast<const char*>(member));
	}
}

void QProgressDialog_Reset(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "reset");
}

void QProgressDialog_ResetDefault(void* ptr)
{
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::reset();
}

void QProgressDialog_SetAutoClose(void* ptr, char close)
{
	static_cast<QProgressDialog*>(ptr)->setAutoClose(close != 0);
}

void QProgressDialog_SetAutoReset(void* ptr, char reset)
{
	static_cast<QProgressDialog*>(ptr)->setAutoReset(reset != 0);
}

void QProgressDialog_SetBar(void* ptr, void* bar)
{
	static_cast<QProgressDialog*>(ptr)->setBar(static_cast<QProgressBar*>(bar));
}

void QProgressDialog_SetCancelButton(void* ptr, void* cancelButton)
{
	static_cast<QProgressDialog*>(ptr)->setCancelButton(static_cast<QPushButton*>(cancelButton));
}

void QProgressDialog_SetCancelButtonText(void* ptr, struct QtWidgets_PackedString cancelButtonText)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setCancelButtonText", Q_ARG(const QString, QString::fromUtf8(cancelButtonText.data, cancelButtonText.len)));
}

void QProgressDialog_SetCancelButtonTextDefault(void* ptr, struct QtWidgets_PackedString cancelButtonText)
{
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setCancelButtonText(QString::fromUtf8(cancelButtonText.data, cancelButtonText.len));
}

void QProgressDialog_SetLabel(void* ptr, void* label)
{
	static_cast<QProgressDialog*>(ptr)->setLabel(static_cast<QLabel*>(label));
}

void QProgressDialog_SetLabelText(void* ptr, struct QtWidgets_PackedString text)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setLabelText", Q_ARG(const QString, QString::fromUtf8(text.data, text.len)));
}

void QProgressDialog_SetLabelTextDefault(void* ptr, struct QtWidgets_PackedString text)
{
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setLabelText(QString::fromUtf8(text.data, text.len));
}

void QProgressDialog_SetMaximum(void* ptr, int maximum)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setMaximum", Q_ARG(int, maximum));
}

void QProgressDialog_SetMaximumDefault(void* ptr, int maximum)
{
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setMaximum(maximum);
}

void QProgressDialog_SetMinimum(void* ptr, int minimum)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setMinimum", Q_ARG(int, minimum));
}

void QProgressDialog_SetMinimumDefault(void* ptr, int minimum)
{
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setMinimum(minimum);
}

void QProgressDialog_SetMinimumDuration(void* ptr, int ms)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setMinimumDuration", Q_ARG(int, ms));
}

void QProgressDialog_SetMinimumDurationDefault(void* ptr, int ms)
{
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setMinimumDuration(ms);
}

void QProgressDialog_SetRange(void* ptr, int minimum, int maximum)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setRange", Q_ARG(int, minimum), Q_ARG(int, maximum));
}

void QProgressDialog_SetRangeDefault(void* ptr, int minimum, int maximum)
{
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setRange(minimum, maximum);
}

void QProgressDialog_SetValue(void* ptr, int progress)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setValue", Q_ARG(int, progress));
}

void QProgressDialog_SetValueDefault(void* ptr, int progress)
{
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setValue(progress);
}

int QProgressDialog_Value(void* ptr)
{
	return static_cast<QProgressDialog*>(ptr)->value();
}

char QProgressDialog_WasCanceled(void* ptr)
{
	return static_cast<QProgressDialog*>(ptr)->wasCanceled();
}

void QProgressDialog_DestroyQProgressDialog(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->~QProgressDialog();
}

void QProgressDialog_DestroyQProgressDialogDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQProxyStyle: public QProxyStyle
{
public:
	MyQProxyStyle(QStyle *style = Q_NULLPTR) : QProxyStyle(style) {QProxyStyle_QProxyStyle_QRegisterMetaType();};
	MyQProxyStyle(const QString &key) : QProxyStyle(key) {QProxyStyle_QProxyStyle_QRegisterMetaType();};
	void drawComplexControl(QStyle::ComplexControl control, const QStyleOptionComplex * option, QPainter * painter, const QWidget * widget) const { callbackQCommonStyle_DrawComplexControl(const_cast<void*>(static_cast<const void*>(this)), control, const_cast<QStyleOptionComplex*>(option), painter, const_cast<QWidget*>(widget)); };
	void drawControl(QStyle::ControlElement element, const QStyleOption * option, QPainter * painter, const QWidget * widget) const { callbackQCommonStyle_DrawControl(const_cast<void*>(static_cast<const void*>(this)), element, const_cast<QStyleOption*>(option), painter, const_cast<QWidget*>(widget)); };
	void drawItemPixmap(QPainter * painter, const QRect & rect, int alignment, const QPixmap & pixmap) const { callbackQStyle_DrawItemPixmap(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QRect*>(&rect), alignment, const_cast<QPixmap*>(&pixmap)); };
	void drawItemText(QPainter * painter, const QRect & rect, int flags, const QPalette & pal, bool enabled, const QString & text, QPalette::ColorRole textRole) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQStyle_DrawItemText(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QRect*>(&rect), flags, const_cast<QPalette*>(&pal), enabled, textPacked, textRole); };
	void drawPrimitive(QStyle::PrimitiveElement element, const QStyleOption * option, QPainter * painter, const QWidget * widget) const { callbackQCommonStyle_DrawPrimitive(const_cast<void*>(static_cast<const void*>(this)), element, const_cast<QStyleOption*>(option), painter, const_cast<QWidget*>(widget)); };
	bool event(QEvent * e) { return callbackQStyle_Event(this, e) != 0; };
	QPixmap generatedIconPixmap(QIcon::Mode iconMode, const QPixmap & pixmap, const QStyleOption * opt) const { return *static_cast<QPixmap*>(callbackQCommonStyle_GeneratedIconPixmap(const_cast<void*>(static_cast<const void*>(this)), iconMode, const_cast<QPixmap*>(&pixmap), const_cast<QStyleOption*>(opt))); };
	QStyle::SubControl hitTestComplexControl(QStyle::ComplexControl control, const QStyleOptionComplex * option, const QPoint & pos, const QWidget * widget) const { return static_cast<QStyle::SubControl>(callbackQCommonStyle_HitTestComplexControl(const_cast<void*>(static_cast<const void*>(this)), control, const_cast<QStyleOptionComplex*>(option), const_cast<QPoint*>(&pos), const_cast<QWidget*>(widget))); };
	QRect itemPixmapRect(const QRect & r, int flags, const QPixmap & pixmap) const { return *static_cast<QRect*>(callbackQStyle_ItemPixmapRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QRect*>(&r), flags, const_cast<QPixmap*>(&pixmap))); };
	QRect itemTextRect(const QFontMetrics & fm, const QRect & r, int flags, bool enabled, const QString & text) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };return *static_cast<QRect*>(callbackQStyle_ItemTextRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QFontMetrics*>(&fm), const_cast<QRect*>(&r), flags, enabled, textPacked)); };
	int layoutSpacing(QSizePolicy::ControlType control1, QSizePolicy::ControlType control2, Qt::Orientation orientation, const QStyleOption * option, const QWidget * widget) const { return callbackQCommonStyle_LayoutSpacing(const_cast<void*>(static_cast<const void*>(this)), control1, control2, orientation, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget)); };
	int pixelMetric(QStyle::PixelMetric metric, const QStyleOption * option, const QWidget * widget) const { return callbackQCommonStyle_PixelMetric(const_cast<void*>(static_cast<const void*>(this)), metric, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget)); };
	void polish(QWidget * widget) { callbackQStyle_Polish(this, widget); };
	void polish(QPalette & pal) { callbackQStyle_Polish2(this, static_cast<QPalette*>(&pal)); };
	void polish(QApplication * app) { callbackQStyle_Polish3(this, app); };
	QSize sizeFromContents(QStyle::ContentsType ty, const QStyleOption * option, const QSize & size, const QWidget * widget) const { return *static_cast<QSize*>(callbackQCommonStyle_SizeFromContents(const_cast<void*>(static_cast<const void*>(this)), ty, const_cast<QStyleOption*>(option), const_cast<QSize*>(&size), const_cast<QWidget*>(widget))); };
	QIcon standardIcon(QStyle::StandardPixmap standardIcon, const QStyleOption * option, const QWidget * widget) const { return *static_cast<QIcon*>(callbackQProxyStyle_StandardIcon(const_cast<void*>(static_cast<const void*>(this)), standardIcon, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
	QPalette standardPalette() const { return *static_cast<QPalette*>(callbackQStyle_StandardPalette(const_cast<void*>(static_cast<const void*>(this)))); };
	QPixmap standardPixmap(QStyle::StandardPixmap standardPixmap, const QStyleOption * opt, const QWidget * widget) const { return *static_cast<QPixmap*>(callbackQCommonStyle_StandardPixmap(const_cast<void*>(static_cast<const void*>(this)), standardPixmap, const_cast<QStyleOption*>(opt), const_cast<QWidget*>(widget))); };
	int styleHint(QStyle::StyleHint hint, const QStyleOption * option, const QWidget * widget, QStyleHintReturn * returnData) const { return callbackQCommonStyle_StyleHint(const_cast<void*>(static_cast<const void*>(this)), hint, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget), returnData); };
	QRect subControlRect(QStyle::ComplexControl cc, const QStyleOptionComplex * option, QStyle::SubControl sc, const QWidget * widget) const { return *static_cast<QRect*>(callbackQCommonStyle_SubControlRect(const_cast<void*>(static_cast<const void*>(this)), cc, const_cast<QStyleOptionComplex*>(option), sc, const_cast<QWidget*>(widget))); };
	QRect subElementRect(QStyle::SubElement element, const QStyleOption * option, const QWidget * widget) const { return *static_cast<QRect*>(callbackQCommonStyle_SubElementRect(const_cast<void*>(static_cast<const void*>(this)), element, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
	void unpolish(QWidget * widget) { callbackQStyle_Unpolish(this, widget); };
	void unpolish(QApplication * app) { callbackQStyle_Unpolish2(this, app); };
	 ~MyQProxyStyle() { callbackQProxyStyle_DestroyQProxyStyle(this); };
	void childEvent(QChildEvent * event) { callbackQStyle_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQStyle_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQStyle_CustomEvent(this, event); };
	void deleteLater() { callbackQStyle_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQStyle_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQStyle_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQStyle_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStyle_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQStyle_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQStyle_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QProxyStyle*)
Q_DECLARE_METATYPE(MyQProxyStyle*)

int QProxyStyle_QProxyStyle_QRegisterMetaType(){qRegisterMetaType<QProxyStyle*>(); return qRegisterMetaType<MyQProxyStyle*>();}

void* QProxyStyle_NewQProxyStyle(void* style)
{
	return new MyQProxyStyle(static_cast<QStyle*>(style));
}

void* QProxyStyle_NewQProxyStyle2(struct QtWidgets_PackedString key)
{
	return new MyQProxyStyle(QString::fromUtf8(key.data, key.len));
}

void* QProxyStyle_BaseStyle(void* ptr)
{
	return static_cast<QProxyStyle*>(ptr)->baseStyle();
}

void QProxyStyle_SetBaseStyle(void* ptr, void* style)
{
	static_cast<QProxyStyle*>(ptr)->setBaseStyle(static_cast<QStyle*>(style));
}

void* QProxyStyle_StandardIcon(void* ptr, long long standardIcon, void* option, void* widget)
{
		return new QIcon(static_cast<QProxyStyle*>(ptr)->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget)));
}

void* QProxyStyle_StandardIconDefault(void* ptr, long long standardIcon, void* option, void* widget)
{
		return new QIcon(static_cast<QProxyStyle*>(ptr)->QProxyStyle::standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget)));
}

void QProxyStyle_DestroyQProxyStyle(void* ptr)
{
	static_cast<QProxyStyle*>(ptr)->~QProxyStyle();
}

void QProxyStyle_DestroyQProxyStyleDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQPushButton: public QPushButton
{
public:
	MyQPushButton(QWidget *parent = Q_NULLPTR) : QPushButton(parent) {QPushButton_QPushButton_QRegisterMetaType();};
	MyQPushButton(const QString &text, QWidget *parent = Q_NULLPTR) : QPushButton(text, parent) {QPushButton_QPushButton_QRegisterMetaType();};
	MyQPushButton(const QIcon &icon, const QString &text, QWidget *parent = Q_NULLPTR) : QPushButton(icon, text, parent) {QPushButton_QPushButton_QRegisterMetaType();};
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void focusInEvent(QFocusEvent * e) { callbackQWidget_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQWidget_FocusOutEvent(this, e); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * vqp) { callbackQPushButton_PaintEvent(this, vqp); };
	void showMenu() { callbackQPushButton_ShowMenu(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQPushButton() { callbackQPushButton_DestroyQPushButton(this); };
	void animateClick(int msec) { callbackQAbstractButton_AnimateClick(this, msec); };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void checkStateSet() { callbackQAbstractButton_CheckStateSet(this); };
	void click() { callbackQAbstractButton_Click(this); };
	void Signal_Clicked(bool checked) { callbackQAbstractButton_Clicked(this, checked); };
	bool hitButton(const QPoint & pos) const { return callbackQAbstractButton_HitButton(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&pos)) != 0; };
	void keyReleaseEvent(QKeyEvent * e) { callbackQWidget_KeyReleaseEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void nextCheckState() { callbackQAbstractButton_NextCheckState(this); };
	void Signal_Pressed() { callbackQAbstractButton_Pressed(this); };
	void Signal_Released() { callbackQAbstractButton_Released(this); };
	void setChecked(bool vbo) { callbackQAbstractButton_SetChecked(this, vbo); };
	void setIconSize(const QSize & size) { callbackQAbstractButton_SetIconSize(this, const_cast<QSize*>(&size)); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void toggle() { callbackQAbstractButton_Toggle(this); };
	void Signal_Toggled(bool checked) { callbackQAbstractButton_Toggled(this, checked); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QPushButton*)
Q_DECLARE_METATYPE(MyQPushButton*)

int QPushButton_QPushButton_QRegisterMetaType(){qRegisterMetaType<QPushButton*>(); return qRegisterMetaType<MyQPushButton*>();}

void* QPushButton_NewQPushButton(void* parent)
{
		return new MyQPushButton(static_cast<QWidget*>(parent));
}

void* QPushButton_NewQPushButton2(struct QtWidgets_PackedString text, void* parent)
{
		return new MyQPushButton(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(parent));
}

void* QPushButton_NewQPushButton3(void* icon, struct QtWidgets_PackedString text, void* parent)
{
		return new MyQPushButton(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(parent));
}

char QPushButton_AutoDefault(void* ptr)
{
	return static_cast<QPushButton*>(ptr)->autoDefault();
}

void QPushButton_InitStyleOption(void* ptr, void* option)
{
	static_cast<QPushButton*>(ptr)->initStyleOption(static_cast<QStyleOptionButton*>(option));
}

char QPushButton_IsDefault(void* ptr)
{
	return static_cast<QPushButton*>(ptr)->isDefault();
}

char QPushButton_IsFlat(void* ptr)
{
	return static_cast<QPushButton*>(ptr)->isFlat();
}

void* QPushButton_Menu(void* ptr)
{
	return static_cast<QPushButton*>(ptr)->menu();
}

void QPushButton_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QPushButton*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QPushButton_PaintEventDefault(void* ptr, void* vqp)
{
	if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::paintEvent(static_cast<QPaintEvent*>(vqp));
	} else {
		static_cast<QPushButton*>(ptr)->QPushButton::paintEvent(static_cast<QPaintEvent*>(vqp));
	}
}

void QPushButton_SetAutoDefault(void* ptr, char vbo)
{
	static_cast<QPushButton*>(ptr)->setAutoDefault(vbo != 0);
}

void QPushButton_SetDefault(void* ptr, char vbo)
{
	static_cast<QPushButton*>(ptr)->setDefault(vbo != 0);
}

void QPushButton_SetFlat(void* ptr, char vbo)
{
	static_cast<QPushButton*>(ptr)->setFlat(vbo != 0);
}

void QPushButton_SetMenu(void* ptr, void* menu)
{
	static_cast<QPushButton*>(ptr)->setMenu(static_cast<QMenu*>(menu));
}

void QPushButton_ShowMenu(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "showMenu");
}

void QPushButton_ShowMenuDefault(void* ptr)
{
	if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::showMenu();
	} else {
		static_cast<QPushButton*>(ptr)->QPushButton::showMenu();
	}
}

void QPushButton_DestroyQPushButton(void* ptr)
{
	static_cast<QPushButton*>(ptr)->~QPushButton();
}

void QPushButton_DestroyQPushButtonDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQRadioButton: public QRadioButton
{
public:
	MyQRadioButton(QWidget *parent = Q_NULLPTR) : QRadioButton(parent) {QRadioButton_QRadioButton_QRegisterMetaType();};
	MyQRadioButton(const QString &text, QWidget *parent = Q_NULLPTR) : QRadioButton(text, parent) {QRadioButton_QRadioButton_QRegisterMetaType();};
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	bool hitButton(const QPoint & pos) const { return callbackQAbstractButton_HitButton(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&pos)) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void paintEvent(QPaintEvent * vqp) { callbackQRadioButton_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQRadioButton() { callbackQRadioButton_DestroyQRadioButton(this); };
	void animateClick(int msec) { callbackQAbstractButton_AnimateClick(this, msec); };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void checkStateSet() { callbackQAbstractButton_CheckStateSet(this); };
	void click() { callbackQAbstractButton_Click(this); };
	void Signal_Clicked(bool checked) { callbackQAbstractButton_Clicked(this, checked); };
	void focusInEvent(QFocusEvent * e) { callbackQWidget_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQWidget_FocusOutEvent(this, e); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQWidget_KeyReleaseEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void nextCheckState() { callbackQAbstractButton_NextCheckState(this); };
	void Signal_Pressed() { callbackQAbstractButton_Pressed(this); };
	void Signal_Released() { callbackQAbstractButton_Released(this); };
	void setChecked(bool vbo) { callbackQAbstractButton_SetChecked(this, vbo); };
	void setIconSize(const QSize & size) { callbackQAbstractButton_SetIconSize(this, const_cast<QSize*>(&size)); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void toggle() { callbackQAbstractButton_Toggle(this); };
	void Signal_Toggled(bool checked) { callbackQAbstractButton_Toggled(this, checked); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QRadioButton*)
Q_DECLARE_METATYPE(MyQRadioButton*)

int QRadioButton_QRadioButton_QRegisterMetaType(){qRegisterMetaType<QRadioButton*>(); return qRegisterMetaType<MyQRadioButton*>();}

void* QRadioButton_NewQRadioButton(void* parent)
{
		return new MyQRadioButton(static_cast<QWidget*>(parent));
}

void* QRadioButton_NewQRadioButton2(struct QtWidgets_PackedString text, void* parent)
{
		return new MyQRadioButton(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(parent));
}

void QRadioButton_InitStyleOption(void* ptr, void* option)
{
	static_cast<QRadioButton*>(ptr)->initStyleOption(static_cast<QStyleOptionButton*>(option));
}

void QRadioButton_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QRadioButton*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QRadioButton_PaintEventDefault(void* ptr, void* vqp)
{
		static_cast<QRadioButton*>(ptr)->QRadioButton::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QRadioButton_DestroyQRadioButton(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->~QRadioButton();
}

void QRadioButton_DestroyQRadioButtonDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQRubberBand: public QRubberBand
{
public:
	MyQRubberBand(QRubberBand::Shape s, QWidget *p = Q_NULLPTR) : QRubberBand(s, p) {QRubberBand_QRubberBand_QRegisterMetaType();};
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void moveEvent(QMoveEvent * vqm) { callbackQWidget_MoveEvent(this, vqm); };
	void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
	void resizeEvent(QResizeEvent * vqr) { callbackQWidget_ResizeEvent(this, vqr); };
	void showEvent(QShowEvent * e) { callbackQWidget_ShowEvent(this, e); };
	 ~MyQRubberBand() { callbackQRubberBand_DestroyQRubberBand(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QRubberBand*)
Q_DECLARE_METATYPE(MyQRubberBand*)

int QRubberBand_QRubberBand_QRegisterMetaType(){qRegisterMetaType<QRubberBand*>(); return qRegisterMetaType<MyQRubberBand*>();}

void* QRubberBand_NewQRubberBand(long long s, void* p)
{
		return new MyQRubberBand(static_cast<QRubberBand::Shape>(s), static_cast<QWidget*>(p));
}

void QRubberBand_InitStyleOption(void* ptr, void* option)
{
	static_cast<QRubberBand*>(ptr)->initStyleOption(static_cast<QStyleOptionRubberBand*>(option));
}

long long QRubberBand_Shape(void* ptr)
{
	return static_cast<QRubberBand*>(ptr)->shape();
}

void QRubberBand_DestroyQRubberBand(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->~QRubberBand();
}

void QRubberBand_DestroyQRubberBandDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQScrollArea: public QScrollArea
{
public:
	MyQScrollArea(QWidget *parent = Q_NULLPTR) : QScrollArea(parent) {QScrollArea_QScrollArea_QRegisterMetaType();};
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	bool eventFilter(QObject * o, QEvent * e) { return callbackQWidget_EventFilter(this, o, e) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void resizeEvent(QResizeEvent * vqr) { callbackQWidget_ResizeEvent(this, vqr); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQScrollArea() { callbackQScrollArea_DestroyQScrollArea(this); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQWidget_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QScrollArea*)
Q_DECLARE_METATYPE(MyQScrollArea*)

int QScrollArea_QScrollArea_QRegisterMetaType(){qRegisterMetaType<QScrollArea*>(); return qRegisterMetaType<MyQScrollArea*>();}

void* QScrollArea_NewQScrollArea(void* parent)
{
		return new MyQScrollArea(static_cast<QWidget*>(parent));
}

long long QScrollArea_Alignment(void* ptr)
{
	return static_cast<QScrollArea*>(ptr)->alignment();
}

void QScrollArea_EnsureVisible(void* ptr, int x, int y, int xmargin, int ymargin)
{
	static_cast<QScrollArea*>(ptr)->ensureVisible(x, y, xmargin, ymargin);
}

void QScrollArea_EnsureWidgetVisible(void* ptr, void* childWidget, int xmargin, int ymargin)
{
		static_cast<QScrollArea*>(ptr)->ensureWidgetVisible(static_cast<QWidget*>(childWidget), xmargin, ymargin);
}

void QScrollArea_SetAlignment(void* ptr, long long vqt)
{
	static_cast<QScrollArea*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(vqt));
}

void QScrollArea_SetWidget(void* ptr, void* widget)
{
		static_cast<QScrollArea*>(ptr)->setWidget(static_cast<QWidget*>(widget));
}

void QScrollArea_SetWidgetResizable(void* ptr, char resizable)
{
	static_cast<QScrollArea*>(ptr)->setWidgetResizable(resizable != 0);
}

void* QScrollArea_TakeWidget(void* ptr)
{
	return static_cast<QScrollArea*>(ptr)->takeWidget();
}

void* QScrollArea_Widget(void* ptr)
{
	return static_cast<QScrollArea*>(ptr)->widget();
}

char QScrollArea_WidgetResizable(void* ptr)
{
	return static_cast<QScrollArea*>(ptr)->widgetResizable();
}

void QScrollArea_DestroyQScrollArea(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->~QScrollArea();
}

void QScrollArea_DestroyQScrollAreaDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQScrollBar: public QScrollBar
{
public:
	MyQScrollBar(QWidget *parent = Q_NULLPTR) : QScrollBar(parent) {QScrollBar_QScrollBar_QRegisterMetaType();};
	MyQScrollBar(Qt::Orientation orientation, QWidget *parent = Q_NULLPTR) : QScrollBar(orientation, parent) {QScrollBar_QScrollBar_QRegisterMetaType();};
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void hideEvent(QHideEvent * vqh) { callbackQWidget_HideEvent(this, vqh); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void sliderChange(QAbstractSlider::SliderChange change) { callbackQAbstractSlider_SliderChange(this, change); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	 ~MyQScrollBar() { callbackQScrollBar_DestroyQScrollBar(this); };
	void Signal_ActionTriggered(int action) { callbackQAbstractSlider_ActionTriggered(this, action); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void keyPressEvent(QKeyEvent * ev) { callbackQWidget_KeyPressEvent(this, ev); };
	void Signal_RangeChanged(int min, int max) { callbackQAbstractSlider_RangeChanged(this, min, max); };
	void setOrientation(Qt::Orientation vqt) { callbackQAbstractSlider_SetOrientation(this, vqt); };
	void setRange(int min, int max) { callbackQAbstractSlider_SetRange(this, min, max); };
	void setValue(int vin) { callbackQAbstractSlider_SetValue(this, vin); };
	void Signal_SliderMoved(int value) { callbackQAbstractSlider_SliderMoved(this, value); };
	void Signal_SliderPressed() { callbackQAbstractSlider_SliderPressed(this); };
	void Signal_SliderReleased() { callbackQAbstractSlider_SliderReleased(this); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void Signal_ValueChanged(int value) { callbackQAbstractSlider_ValueChanged(this, value); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QScrollBar*)
Q_DECLARE_METATYPE(MyQScrollBar*)

int QScrollBar_QScrollBar_QRegisterMetaType(){qRegisterMetaType<QScrollBar*>(); return qRegisterMetaType<MyQScrollBar*>();}

void* QScrollBar_NewQScrollBar(void* parent)
{
		return new MyQScrollBar(static_cast<QWidget*>(parent));
}

void* QScrollBar_NewQScrollBar2(long long orientation, void* parent)
{
		return new MyQScrollBar(static_cast<Qt::Orientation>(orientation), static_cast<QWidget*>(parent));
}

void QScrollBar_InitStyleOption(void* ptr, void* option)
{
	static_cast<QScrollBar*>(ptr)->initStyleOption(static_cast<QStyleOptionSlider*>(option));
}

void QScrollBar_DestroyQScrollBar(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->~QScrollBar();
}

void QScrollBar_DestroyQScrollBarDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQScroller: public QScroller
{
public:
	void ensureVisible(const QRectF & rect, qreal xmargin, qreal ymargin) { callbackQScroller_EnsureVisible(this, const_cast<QRectF*>(&rect), xmargin, ymargin); };
	void ensureVisible(const QRectF & rect, qreal xmargin, qreal ymargin, int scrollTime) { callbackQScroller_EnsureVisible2(this, const_cast<QRectF*>(&rect), xmargin, ymargin, scrollTime); };
	void resendPrepareEvent() { callbackQScroller_ResendPrepareEvent(this); };
	void scrollTo(const QPointF & pos) { callbackQScroller_ScrollTo(this, const_cast<QPointF*>(&pos)); };
	void scrollTo(const QPointF & pos, int scrollTime) { callbackQScroller_ScrollTo2(this, const_cast<QPointF*>(&pos), scrollTime); };
	void Signal_ScrollerPropertiesChanged(const QScrollerProperties & newProperties) { callbackQScroller_ScrollerPropertiesChanged(this, const_cast<QScrollerProperties*>(&newProperties)); };
	void setScrollerProperties(const QScrollerProperties & prop) { callbackQScroller_SetScrollerProperties(this, const_cast<QScrollerProperties*>(&prop)); };
	void Signal_StateChanged(QScroller::State newState) { callbackQScroller_StateChanged(this, newState); };
	void childEvent(QChildEvent * event) { callbackQScroller_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQScroller_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQScroller_CustomEvent(this, event); };
	void deleteLater() { callbackQScroller_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQScroller_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQScroller_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQScroller_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQScroller_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQScroller_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQScroller_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQScroller_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QScroller*)
Q_DECLARE_METATYPE(MyQScroller*)

int QScroller_QScroller_QRegisterMetaType(){qRegisterMetaType<QScroller*>(); return qRegisterMetaType<MyQScroller*>();}

struct QtWidgets_PackedList QScroller_QScroller_ActiveScrollers()
{
	return ({ QList<QScroller *>* tmpValue3b5996 = new QList<QScroller *>(QScroller::activeScrollers()); QtWidgets_PackedList { tmpValue3b5996, tmpValue3b5996->size() }; });
}

void QScroller_EnsureVisible(void* ptr, void* rect, double xmargin, double ymargin)
{
	QMetaObject::invokeMethod(static_cast<QScroller*>(ptr), "ensureVisible", Q_ARG(const QRectF, *static_cast<QRectF*>(rect)), Q_ARG(qreal, xmargin), Q_ARG(qreal, ymargin));
}

void QScroller_EnsureVisibleDefault(void* ptr, void* rect, double xmargin, double ymargin)
{
		static_cast<QScroller*>(ptr)->QScroller::ensureVisible(*static_cast<QRectF*>(rect), xmargin, ymargin);
}

void QScroller_EnsureVisible2(void* ptr, void* rect, double xmargin, double ymargin, int scrollTime)
{
	QMetaObject::invokeMethod(static_cast<QScroller*>(ptr), "ensureVisible", Q_ARG(const QRectF, *static_cast<QRectF*>(rect)), Q_ARG(qreal, xmargin), Q_ARG(qreal, ymargin), Q_ARG(int, scrollTime));
}

void QScroller_EnsureVisible2Default(void* ptr, void* rect, double xmargin, double ymargin, int scrollTime)
{
		static_cast<QScroller*>(ptr)->QScroller::ensureVisible(*static_cast<QRectF*>(rect), xmargin, ymargin, scrollTime);
}

void* QScroller_FinalPosition(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QScroller*>(ptr)->finalPosition(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

long long QScroller_QScroller_GrabGesture(void* target, long long scrollGestureType)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(target))) {
		return QScroller::grabGesture(static_cast<QGraphicsObject*>(target), static_cast<QScroller::ScrollerGestureType>(scrollGestureType));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(target))) {
		return QScroller::grabGesture(static_cast<QGraphicsWidget*>(target), static_cast<QScroller::ScrollerGestureType>(scrollGestureType));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(target))) {
		return QScroller::grabGesture(static_cast<QLayout*>(target), static_cast<QScroller::ScrollerGestureType>(scrollGestureType));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(target))) {
		return QScroller::grabGesture(static_cast<QWidget*>(target), static_cast<QScroller::ScrollerGestureType>(scrollGestureType));
	} else {
		return QScroller::grabGesture(static_cast<QObject*>(target), static_cast<QScroller::ScrollerGestureType>(scrollGestureType));
	}
}

long long QScroller_QScroller_GrabbedGesture(void* target)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(target))) {
		return QScroller::grabbedGesture(static_cast<QGraphicsObject*>(target));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(target))) {
		return QScroller::grabbedGesture(static_cast<QGraphicsWidget*>(target));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(target))) {
		return QScroller::grabbedGesture(static_cast<QLayout*>(target));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(target))) {
		return QScroller::grabbedGesture(static_cast<QWidget*>(target));
	} else {
		return QScroller::grabbedGesture(static_cast<QObject*>(target));
	}
}

char QScroller_HandleInput(void* ptr, long long input, void* position, long long timestamp)
{
	return static_cast<QScroller*>(ptr)->handleInput(static_cast<QScroller::Input>(input), *static_cast<QPointF*>(position), timestamp);
}

char QScroller_QScroller_HasScroller(void* target)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(target))) {
		return QScroller::hasScroller(static_cast<QGraphicsObject*>(target));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(target))) {
		return QScroller::hasScroller(static_cast<QGraphicsWidget*>(target));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(target))) {
		return QScroller::hasScroller(static_cast<QLayout*>(target));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(target))) {
		return QScroller::hasScroller(static_cast<QWidget*>(target));
	} else {
		return QScroller::hasScroller(static_cast<QObject*>(target));
	}
}

void* QScroller_PixelPerMeter(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QScroller*>(ptr)->pixelPerMeter(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QScroller_ResendPrepareEvent(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScroller*>(ptr), "resendPrepareEvent");
}

void QScroller_ResendPrepareEventDefault(void* ptr)
{
		static_cast<QScroller*>(ptr)->QScroller::resendPrepareEvent();
}

void QScroller_ScrollTo(void* ptr, void* pos)
{
	QMetaObject::invokeMethod(static_cast<QScroller*>(ptr), "scrollTo", Q_ARG(const QPointF, *static_cast<QPointF*>(pos)));
}

void QScroller_ScrollToDefault(void* ptr, void* pos)
{
		static_cast<QScroller*>(ptr)->QScroller::scrollTo(*static_cast<QPointF*>(pos));
}

void QScroller_ScrollTo2(void* ptr, void* pos, int scrollTime)
{
	QMetaObject::invokeMethod(static_cast<QScroller*>(ptr), "scrollTo", Q_ARG(const QPointF, *static_cast<QPointF*>(pos)), Q_ARG(int, scrollTime));
}

void QScroller_ScrollTo2Default(void* ptr, void* pos, int scrollTime)
{
		static_cast<QScroller*>(ptr)->QScroller::scrollTo(*static_cast<QPointF*>(pos), scrollTime);
}

void* QScroller_QScroller_Scroller(void* target)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(target))) {
		return QScroller::scroller(static_cast<QGraphicsObject*>(target));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(target))) {
		return QScroller::scroller(static_cast<QGraphicsWidget*>(target));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(target))) {
		return QScroller::scroller(static_cast<QLayout*>(target));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(target))) {
		return QScroller::scroller(static_cast<QWidget*>(target));
	} else {
		return QScroller::scroller(static_cast<QObject*>(target));
	}
}

void* QScroller_QScroller_Scroller2(void* target)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(target))) {
		return const_cast<QScroller*>(QScroller::scroller(static_cast<QGraphicsObject*>(target)));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(target))) {
		return const_cast<QScroller*>(QScroller::scroller(static_cast<QGraphicsWidget*>(target)));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(target))) {
		return const_cast<QScroller*>(QScroller::scroller(static_cast<QLayout*>(target)));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(target))) {
		return const_cast<QScroller*>(QScroller::scroller(static_cast<QWidget*>(target)));
	} else {
		return const_cast<QScroller*>(QScroller::scroller(static_cast<QObject*>(target)));
	}
}

void* QScroller_ScrollerProperties(void* ptr)
{
	return new QScrollerProperties(static_cast<QScroller*>(ptr)->scrollerProperties());
}

void QScroller_ConnectScrollerPropertiesChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QScroller*>(ptr), static_cast<void (QScroller::*)(const QScrollerProperties &)>(&QScroller::scrollerPropertiesChanged), static_cast<MyQScroller*>(ptr), static_cast<void (MyQScroller::*)(const QScrollerProperties &)>(&MyQScroller::Signal_ScrollerPropertiesChanged), static_cast<Qt::ConnectionType>(t));
}

void QScroller_DisconnectScrollerPropertiesChanged(void* ptr)
{
	QObject::disconnect(static_cast<QScroller*>(ptr), static_cast<void (QScroller::*)(const QScrollerProperties &)>(&QScroller::scrollerPropertiesChanged), static_cast<MyQScroller*>(ptr), static_cast<void (MyQScroller::*)(const QScrollerProperties &)>(&MyQScroller::Signal_ScrollerPropertiesChanged));
}

void QScroller_ScrollerPropertiesChanged(void* ptr, void* newProperties)
{
	static_cast<QScroller*>(ptr)->scrollerPropertiesChanged(*static_cast<QScrollerProperties*>(newProperties));
}

void QScroller_SetScrollerProperties(void* ptr, void* prop)
{
	QMetaObject::invokeMethod(static_cast<QScroller*>(ptr), "setScrollerProperties", Q_ARG(const QScrollerProperties, *static_cast<QScrollerProperties*>(prop)));
}

void QScroller_SetScrollerPropertiesDefault(void* ptr, void* prop)
{
		static_cast<QScroller*>(ptr)->QScroller::setScrollerProperties(*static_cast<QScrollerProperties*>(prop));
}

void QScroller_SetSnapPositionsX(void* ptr, void* positions)
{
	static_cast<QScroller*>(ptr)->setSnapPositionsX(*static_cast<QList<qreal>*>(positions));
}

void QScroller_SetSnapPositionsX2(void* ptr, double first, double interval)
{
	static_cast<QScroller*>(ptr)->setSnapPositionsX(first, interval);
}

void QScroller_SetSnapPositionsY(void* ptr, void* positions)
{
	static_cast<QScroller*>(ptr)->setSnapPositionsY(*static_cast<QList<qreal>*>(positions));
}

void QScroller_SetSnapPositionsY2(void* ptr, double first, double interval)
{
	static_cast<QScroller*>(ptr)->setSnapPositionsY(first, interval);
}

long long QScroller_State(void* ptr)
{
	return static_cast<QScroller*>(ptr)->state();
}

void QScroller_ConnectStateChanged(void* ptr, long long t)
{
	qRegisterMetaType<QScroller::State>();
	QObject::connect(static_cast<QScroller*>(ptr), static_cast<void (QScroller::*)(QScroller::State)>(&QScroller::stateChanged), static_cast<MyQScroller*>(ptr), static_cast<void (MyQScroller::*)(QScroller::State)>(&MyQScroller::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}

void QScroller_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QScroller*>(ptr), static_cast<void (QScroller::*)(QScroller::State)>(&QScroller::stateChanged), static_cast<MyQScroller*>(ptr), static_cast<void (MyQScroller::*)(QScroller::State)>(&MyQScroller::Signal_StateChanged));
}

void QScroller_StateChanged(void* ptr, long long newState)
{
	static_cast<QScroller*>(ptr)->stateChanged(static_cast<QScroller::State>(newState));
}

void QScroller_Stop(void* ptr)
{
	static_cast<QScroller*>(ptr)->stop();
}

void* QScroller_Target(void* ptr)
{
	return static_cast<QScroller*>(ptr)->target();
}

void QScroller_QScroller_UngrabGesture(void* target)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(target))) {
		QScroller::ungrabGesture(static_cast<QGraphicsObject*>(target));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(target))) {
		QScroller::ungrabGesture(static_cast<QGraphicsWidget*>(target));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(target))) {
		QScroller::ungrabGesture(static_cast<QLayout*>(target));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(target))) {
		QScroller::ungrabGesture(static_cast<QWidget*>(target));
	} else {
		QScroller::ungrabGesture(static_cast<QObject*>(target));
	}
}

void* QScroller_Velocity(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QScroller*>(ptr)->velocity(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QScroller___activeScrollers_atList(void* ptr, int i)
{
	return ({QScroller * tmp = static_cast<QList<QScroller *>*>(ptr)->at(i); if (i == static_cast<QList<QScroller *>*>(ptr)->size()-1) { static_cast<QList<QScroller *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QScroller___activeScrollers_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QScroller *>();
}

double QScroller___setSnapPositionsX_positions_atList(void* ptr, int i)
{
	return ({qreal tmp = static_cast<QList<qreal>*>(ptr)->at(i); if (i == static_cast<QList<qreal>*>(ptr)->size()-1) { static_cast<QList<qreal>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QScroller___setSnapPositionsX_positions_setList(void* ptr, double i)
{
	static_cast<QList<qreal>*>(ptr)->append(i);
}

void* QScroller___setSnapPositionsX_positions_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<qreal>();
}

double QScroller___setSnapPositionsY_positions_atList(void* ptr, int i)
{
	return ({qreal tmp = static_cast<QList<qreal>*>(ptr)->at(i); if (i == static_cast<QList<qreal>*>(ptr)->size()-1) { static_cast<QList<qreal>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QScroller___setSnapPositionsY_positions_setList(void* ptr, double i)
{
	static_cast<QList<qreal>*>(ptr)->append(i);
}

void* QScroller___setSnapPositionsY_positions_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<qreal>();
}

void* QScroller___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QScroller___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QScroller___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QScroller___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QScroller___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QScroller___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QScroller___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

void QScroller_DeleteLaterDefault(void* ptr)
{
		static_cast<QScroller*>(ptr)->QScroller::deleteLater();
}

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

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

char QScroller_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QScroller*>(ptr)->QScroller::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QScroller*>(ptr)->QScroller::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QScroller*>(ptr)->QScroller::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QScroller*>(ptr)->QScroller::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QScroller*>(ptr)->QScroller::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQScrollerProperties: public QScrollerProperties
{
public:
	MyQScrollerProperties() : QScrollerProperties() {QScrollerProperties_QScrollerProperties_QRegisterMetaType();};
	MyQScrollerProperties(const QScrollerProperties &sp) : QScrollerProperties(sp) {QScrollerProperties_QScrollerProperties_QRegisterMetaType();};
	 ~MyQScrollerProperties() { callbackQScrollerProperties_DestroyQScrollerProperties(this); };
};

Q_DECLARE_METATYPE(QScrollerProperties*)
Q_DECLARE_METATYPE(MyQScrollerProperties*)

int QScrollerProperties_QScrollerProperties_QRegisterMetaType(){qRegisterMetaType<QScrollerProperties*>(); return qRegisterMetaType<MyQScrollerProperties*>();}

void* QScrollerProperties_NewQScrollerProperties()
{
	return new MyQScrollerProperties();
}

void* QScrollerProperties_NewQScrollerProperties2(void* sp)
{
	return new MyQScrollerProperties(*static_cast<QScrollerProperties*>(sp));
}

void* QScrollerProperties_ScrollMetric(void* ptr, long long metric)
{
	return new QVariant(static_cast<QScrollerProperties*>(ptr)->scrollMetric(static_cast<QScrollerProperties::ScrollMetric>(metric)));
}

void QScrollerProperties_QScrollerProperties_SetDefaultScrollerProperties(void* sp)
{
	QScrollerProperties::setDefaultScrollerProperties(*static_cast<QScrollerProperties*>(sp));
}

void QScrollerProperties_SetScrollMetric(void* ptr, long long metric, void* value)
{
	static_cast<QScrollerProperties*>(ptr)->setScrollMetric(static_cast<QScrollerProperties::ScrollMetric>(metric), *static_cast<QVariant*>(value));
}

void QScrollerProperties_QScrollerProperties_UnsetDefaultScrollerProperties()
{
	QScrollerProperties::unsetDefaultScrollerProperties();
}

void QScrollerProperties_DestroyQScrollerProperties(void* ptr)
{
	static_cast<QScrollerProperties*>(ptr)->~QScrollerProperties();
}

void QScrollerProperties_DestroyQScrollerPropertiesDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQShortcut: public QShortcut
{
public:
	MyQShortcut(QWidget *parent) : QShortcut(parent) {QShortcut_QShortcut_QRegisterMetaType();};
	MyQShortcut(const QKeySequence &key, QWidget *parent, const char *member = Q_NULLPTR, const char *ambiguousMember = Q_NULLPTR, Qt::ShortcutContext context = Qt::WindowShortcut) : QShortcut(key, parent, member, ambiguousMember, context) {QShortcut_QShortcut_QRegisterMetaType();};
	void Signal_Activated() { callbackQShortcut_Activated(this); };
	void Signal_ActivatedAmbiguously() { callbackQShortcut_ActivatedAmbiguously(this); };
	 ~MyQShortcut() { callbackQShortcut_DestroyQShortcut(this); };
	void childEvent(QChildEvent * event) { callbackQShortcut_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQShortcut_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQShortcut_CustomEvent(this, event); };
	void deleteLater() { callbackQShortcut_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQShortcut_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQShortcut_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQShortcut_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQShortcut_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQShortcut_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQShortcut_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQShortcut_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QShortcut*)
Q_DECLARE_METATYPE(MyQShortcut*)

int QShortcut_QShortcut_QRegisterMetaType(){qRegisterMetaType<QShortcut*>(); return qRegisterMetaType<MyQShortcut*>();}

void* QShortcut_NewQShortcut(void* parent)
{
		return new MyQShortcut(static_cast<QWidget*>(parent));
}

void* QShortcut_NewQShortcut2(void* key, void* parent, char* member, char* ambiguousMember, long long context)
{
		return new MyQShortcut(*static_cast<QKeySequence*>(key), static_cast<QWidget*>(parent), const_cast<const char*>(member), const_cast<const char*>(ambiguousMember), static_cast<Qt::ShortcutContext>(context));
}

void QShortcut_ConnectActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QShortcut*>(ptr), static_cast<void (QShortcut::*)()>(&QShortcut::activated), static_cast<MyQShortcut*>(ptr), static_cast<void (MyQShortcut::*)()>(&MyQShortcut::Signal_Activated), static_cast<Qt::ConnectionType>(t));
}

void QShortcut_DisconnectActivated(void* ptr)
{
	QObject::disconnect(static_cast<QShortcut*>(ptr), static_cast<void (QShortcut::*)()>(&QShortcut::activated), static_cast<MyQShortcut*>(ptr), static_cast<void (MyQShortcut::*)()>(&MyQShortcut::Signal_Activated));
}

void QShortcut_Activated(void* ptr)
{
	static_cast<QShortcut*>(ptr)->activated();
}

void QShortcut_ConnectActivatedAmbiguously(void* ptr, long long t)
{
	QObject::connect(static_cast<QShortcut*>(ptr), static_cast<void (QShortcut::*)()>(&QShortcut::activatedAmbiguously), static_cast<MyQShortcut*>(ptr), static_cast<void (MyQShortcut::*)()>(&MyQShortcut::Signal_ActivatedAmbiguously), static_cast<Qt::ConnectionType>(t));
}

void QShortcut_DisconnectActivatedAmbiguously(void* ptr)
{
	QObject::disconnect(static_cast<QShortcut*>(ptr), static_cast<void (QShortcut::*)()>(&QShortcut::activatedAmbiguously), static_cast<MyQShortcut*>(ptr), static_cast<void (MyQShortcut::*)()>(&MyQShortcut::Signal_ActivatedAmbiguously));
}

void QShortcut_ActivatedAmbiguously(void* ptr)
{
	static_cast<QShortcut*>(ptr)->activatedAmbiguously();
}

char QShortcut_AutoRepeat(void* ptr)
{
	return static_cast<QShortcut*>(ptr)->autoRepeat();
}

long long QShortcut_Context(void* ptr)
{
	return static_cast<QShortcut*>(ptr)->context();
}

int QShortcut_Id(void* ptr)
{
	return static_cast<QShortcut*>(ptr)->id();
}

char QShortcut_IsEnabled(void* ptr)
{
	return static_cast<QShortcut*>(ptr)->isEnabled();
}

void* QShortcut_Key(void* ptr)
{
	return new QKeySequence(static_cast<QShortcut*>(ptr)->key());
}

void* QShortcut_ParentWidget(void* ptr)
{
	return static_cast<QShortcut*>(ptr)->parentWidget();
}

void QShortcut_SetAutoRepeat(void* ptr, char on)
{
	static_cast<QShortcut*>(ptr)->setAutoRepeat(on != 0);
}

void QShortcut_SetContext(void* ptr, long long context)
{
	static_cast<QShortcut*>(ptr)->setContext(static_cast<Qt::ShortcutContext>(context));
}

void QShortcut_SetEnabled(void* ptr, char enable)
{
	static_cast<QShortcut*>(ptr)->setEnabled(enable != 0);
}

void QShortcut_SetKey(void* ptr, void* key)
{
	static_cast<QShortcut*>(ptr)->setKey(*static_cast<QKeySequence*>(key));
}

void QShortcut_SetWhatsThis(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QShortcut*>(ptr)->setWhatsThis(QString::fromUtf8(text.data, text.len));
}

struct QtWidgets_PackedString QShortcut_WhatsThis(void* ptr)
{
	return ({ QByteArray* t714906 = new QByteArray(static_cast<QShortcut*>(ptr)->whatsThis().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t714906->prepend("WHITESPACE").constData()+10), t714906->size()-10, t714906 }; });
}

void QShortcut_DestroyQShortcut(void* ptr)
{
	static_cast<QShortcut*>(ptr)->~QShortcut();
}

void QShortcut_DestroyQShortcutDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QShortcut___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QShortcut___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QShortcut___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QShortcut___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QShortcut___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QShortcut___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QShortcut___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

void QShortcut_DeleteLaterDefault(void* ptr)
{
		static_cast<QShortcut*>(ptr)->QShortcut::deleteLater();
}

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

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

char QShortcut_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QShortcut*>(ptr)->QShortcut::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QShortcut*>(ptr)->QShortcut::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QShortcut*>(ptr)->QShortcut::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QShortcut*>(ptr)->QShortcut::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QShortcut*>(ptr)->QShortcut::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQSizeGrip: public QSizeGrip
{
public:
	MyQSizeGrip(QWidget *parent) : QSizeGrip(parent) {QSizeGrip_QSizeGrip_QRegisterMetaType();};
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	bool eventFilter(QObject * o, QEvent * e) { return callbackQWidget_EventFilter(this, o, e) != 0; };
	void hideEvent(QHideEvent * hideEvent) { callbackQWidget_HideEvent(this, hideEvent); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * mouseEvent) { callbackQWidget_MouseReleaseEvent(this, mouseEvent); };
	void moveEvent(QMoveEvent * moveEvent) { callbackQWidget_MoveEvent(this, moveEvent); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void setVisible(bool visible) { callbackQSizeGrip_SetVisible(this, visible); };
	void showEvent(QShowEvent * showEvent) { callbackQWidget_ShowEvent(this, showEvent); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQSizeGrip() { callbackQSizeGrip_DestroyQSizeGrip(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QSizeGrip*)
Q_DECLARE_METATYPE(MyQSizeGrip*)

int QSizeGrip_QSizeGrip_QRegisterMetaType(){qRegisterMetaType<QSizeGrip*>(); return qRegisterMetaType<MyQSizeGrip*>();}

void* QSizeGrip_NewQSizeGrip(void* parent)
{
		return new MyQSizeGrip(static_cast<QWidget*>(parent));
}

void QSizeGrip_SetVisible(void* ptr, char visible)
{
	static_cast<QSizeGrip*>(ptr)->setVisible(visible != 0);
}

void QSizeGrip_SetVisibleDefault(void* ptr, char visible)
{
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::setVisible(visible != 0);
}

void QSizeGrip_DestroyQSizeGrip(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->~QSizeGrip();
}

void QSizeGrip_DestroyQSizeGripDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

Q_DECLARE_METATYPE(QSizePolicy)
Q_DECLARE_METATYPE(QSizePolicy*)
void* QSizePolicy_NewQSizePolicy()
{
	return new QSizePolicy();
}

void* QSizePolicy_NewQSizePolicy2(long long horizontal, long long vertical, long long ty)
{
	return new QSizePolicy(static_cast<QSizePolicy::Policy>(horizontal), static_cast<QSizePolicy::Policy>(vertical), static_cast<QSizePolicy::ControlType>(ty));
}

long long QSizePolicy_ControlType(void* ptr)
{
	return static_cast<QSizePolicy*>(ptr)->controlType();
}

long long QSizePolicy_ExpandingDirections(void* ptr)
{
	return static_cast<QSizePolicy*>(ptr)->expandingDirections();
}

char QSizePolicy_HasHeightForWidth(void* ptr)
{
	return static_cast<QSizePolicy*>(ptr)->hasHeightForWidth();
}

char QSizePolicy_HasWidthForHeight(void* ptr)
{
	return static_cast<QSizePolicy*>(ptr)->hasWidthForHeight();
}

long long QSizePolicy_HorizontalPolicy(void* ptr)
{
	return static_cast<QSizePolicy*>(ptr)->horizontalPolicy();
}

int QSizePolicy_HorizontalStretch(void* ptr)
{
	return static_cast<QSizePolicy*>(ptr)->horizontalStretch();
}

char QSizePolicy_RetainSizeWhenHidden(void* ptr)
{
	return static_cast<QSizePolicy*>(ptr)->retainSizeWhenHidden();
}

void QSizePolicy_SetControlType(void* ptr, long long ty)
{
	static_cast<QSizePolicy*>(ptr)->setControlType(static_cast<QSizePolicy::ControlType>(ty));
}

void QSizePolicy_SetHeightForWidth(void* ptr, char dependent)
{
	static_cast<QSizePolicy*>(ptr)->setHeightForWidth(dependent != 0);
}

void QSizePolicy_SetHorizontalPolicy(void* ptr, long long policy)
{
	static_cast<QSizePolicy*>(ptr)->setHorizontalPolicy(static_cast<QSizePolicy::Policy>(policy));
}

void QSizePolicy_SetHorizontalStretch(void* ptr, int stretchFactor)
{
	static_cast<QSizePolicy*>(ptr)->setHorizontalStretch(stretchFactor);
}

void QSizePolicy_SetRetainSizeWhenHidden(void* ptr, char retainSize)
{
	static_cast<QSizePolicy*>(ptr)->setRetainSizeWhenHidden(retainSize != 0);
}

void QSizePolicy_SetVerticalPolicy(void* ptr, long long policy)
{
	static_cast<QSizePolicy*>(ptr)->setVerticalPolicy(static_cast<QSizePolicy::Policy>(policy));
}

void QSizePolicy_SetVerticalStretch(void* ptr, int stretchFactor)
{
	static_cast<QSizePolicy*>(ptr)->setVerticalStretch(stretchFactor);
}

void QSizePolicy_SetWidthForHeight(void* ptr, char dependent)
{
	static_cast<QSizePolicy*>(ptr)->setWidthForHeight(dependent != 0);
}

void QSizePolicy_Transpose(void* ptr)
{
	static_cast<QSizePolicy*>(ptr)->transpose();
}

void* QSizePolicy_Transposed(void* ptr)
{
	return new QSizePolicy(static_cast<QSizePolicy*>(ptr)->transposed());
}

long long QSizePolicy_VerticalPolicy(void* ptr)
{
	return static_cast<QSizePolicy*>(ptr)->verticalPolicy();
}

int QSizePolicy_VerticalStretch(void* ptr)
{
	return static_cast<QSizePolicy*>(ptr)->verticalStretch();
}

class MyQSlider: public QSlider
{
public:
	MyQSlider(QWidget *parent = Q_NULLPTR) : QSlider(parent) {QSlider_QSlider_QRegisterMetaType();};
	MyQSlider(Qt::Orientation orientation, QWidget *parent = Q_NULLPTR) : QSlider(orientation, parent) {QSlider_QSlider_QRegisterMetaType();};
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseMoveEvent(QMouseEvent * ev) { callbackQWidget_MouseMoveEvent(this, ev); };
	void mousePressEvent(QMouseEvent * ev) { callbackQWidget_MousePressEvent(this, ev); };
	void mouseReleaseEvent(QMouseEvent * ev) { callbackQWidget_MouseReleaseEvent(this, ev); };
	void paintEvent(QPaintEvent * ev) { callbackQWidget_PaintEvent(this, ev); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQSlider() { callbackQSlider_DestroyQSlider(this); };
	void Signal_ActionTriggered(int action) { callbackQAbstractSlider_ActionTriggered(this, action); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void keyPressEvent(QKeyEvent * ev) { callbackQWidget_KeyPressEvent(this, ev); };
	void Signal_RangeChanged(int min, int max) { callbackQAbstractSlider_RangeChanged(this, min, max); };
	void setOrientation(Qt::Orientation vqt) { callbackQAbstractSlider_SetOrientation(this, vqt); };
	void setRange(int min, int max) { callbackQAbstractSlider_SetRange(this, min, max); };
	void setValue(int vin) { callbackQAbstractSlider_SetValue(this, vin); };
	void sliderChange(QAbstractSlider::SliderChange change) { callbackQAbstractSlider_SliderChange(this, change); };
	void Signal_SliderMoved(int value) { callbackQAbstractSlider_SliderMoved(this, value); };
	void Signal_SliderPressed() { callbackQAbstractSlider_SliderPressed(this); };
	void Signal_SliderReleased() { callbackQAbstractSlider_SliderReleased(this); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void Signal_ValueChanged(int value) { callbackQAbstractSlider_ValueChanged(this, value); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QSlider*)
Q_DECLARE_METATYPE(MyQSlider*)

int QSlider_QSlider_QRegisterMetaType(){qRegisterMetaType<QSlider*>(); return qRegisterMetaType<MyQSlider*>();}

void* QSlider_NewQSlider(void* parent)
{
		return new MyQSlider(static_cast<QWidget*>(parent));
}

void* QSlider_NewQSlider2(long long orientation, void* parent)
{
		return new MyQSlider(static_cast<Qt::Orientation>(orientation), static_cast<QWidget*>(parent));
}

void QSlider_InitStyleOption(void* ptr, void* option)
{
	static_cast<QSlider*>(ptr)->initStyleOption(static_cast<QStyleOptionSlider*>(option));
}

void QSlider_SetTickInterval(void* ptr, int ti)
{
	static_cast<QSlider*>(ptr)->setTickInterval(ti);
}

void QSlider_SetTickPosition(void* ptr, long long position)
{
	static_cast<QSlider*>(ptr)->setTickPosition(static_cast<QSlider::TickPosition>(position));
}

int QSlider_TickInterval(void* ptr)
{
	return static_cast<QSlider*>(ptr)->tickInterval();
}

long long QSlider_TickPosition(void* ptr)
{
	return static_cast<QSlider*>(ptr)->tickPosition();
}

void QSlider_DestroyQSlider(void* ptr)
{
	static_cast<QSlider*>(ptr)->~QSlider();
}

void QSlider_DestroyQSliderDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQSpacerItem: public QSpacerItem
{
public:
	MyQSpacerItem(int w, int h, QSizePolicy::Policy hPolicy = QSizePolicy::Minimum, QSizePolicy::Policy vPolicy = QSizePolicy::Minimum) : QSpacerItem(w, h, hPolicy, vPolicy) {QSpacerItem_QSpacerItem_QRegisterMetaType();};
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQSpacerItem_ExpandingDirections(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQSpacerItem_Geometry(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isEmpty() const { return callbackQSpacerItem_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQSpacerItem_MaximumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQSpacerItem_MinimumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	void setGeometry(const QRect & r) { callbackQSpacerItem_SetGeometry(this, const_cast<QRect*>(&r)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQSpacerItem_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayoutItem_SpacerItem(this)); };
	 ~MyQSpacerItem() { callbackQSpacerItem_DestroyQSpacerItem(this); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayoutItem_ControlTypes(const_cast<void*>(static_cast<const void*>(this)))); };
	bool hasHeightForWidth() const { return callbackQLayoutItem_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int vin) const { return callbackQLayoutItem_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), vin); };
	void invalidate() { callbackQLayoutItem_Invalidate(this); };
	QLayout * layout() { return static_cast<QLayout*>(callbackQLayoutItem_Layout(this)); };
	int minimumHeightForWidth(int w) const { return callbackQLayoutItem_MinimumHeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQLayoutItem_Widget(this)); };
};

Q_DECLARE_METATYPE(QSpacerItem*)
Q_DECLARE_METATYPE(MyQSpacerItem*)

int QSpacerItem_QSpacerItem_QRegisterMetaType(){qRegisterMetaType<QSpacerItem*>(); return qRegisterMetaType<MyQSpacerItem*>();}

void* QSpacerItem_NewQSpacerItem(int w, int h, long long hPolicy, long long vPolicy)
{
	return new MyQSpacerItem(w, h, static_cast<QSizePolicy::Policy>(hPolicy), static_cast<QSizePolicy::Policy>(vPolicy));
}

void QSpacerItem_ChangeSize(void* ptr, int w, int h, long long hPolicy, long long vPolicy)
{
	static_cast<QSpacerItem*>(ptr)->changeSize(w, h, static_cast<QSizePolicy::Policy>(hPolicy), static_cast<QSizePolicy::Policy>(vPolicy));
}

long long QSpacerItem_ExpandingDirections(void* ptr)
{
	return static_cast<QSpacerItem*>(ptr)->expandingDirections();
}

long long QSpacerItem_ExpandingDirectionsDefault(void* ptr)
{
		return static_cast<QSpacerItem*>(ptr)->QSpacerItem::expandingDirections();
}

void* QSpacerItem_Geometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QSpacerItem*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

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

char QSpacerItem_IsEmpty(void* ptr)
{
	return static_cast<QSpacerItem*>(ptr)->isEmpty();
}

char QSpacerItem_IsEmptyDefault(void* ptr)
{
		return static_cast<QSpacerItem*>(ptr)->QSpacerItem::isEmpty();
}

void* QSpacerItem_MaximumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSpacerItem*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSpacerItem_MaximumSizeDefault(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QSpacerItem*>(ptr)->QSpacerItem::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSpacerItem_MinimumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSpacerItem*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSpacerItem_MinimumSizeDefault(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QSpacerItem*>(ptr)->QSpacerItem::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QSpacerItem_SetGeometry(void* ptr, void* r)
{
	static_cast<QSpacerItem*>(ptr)->setGeometry(*static_cast<QRect*>(r));
}

void QSpacerItem_SetGeometryDefault(void* ptr, void* r)
{
		static_cast<QSpacerItem*>(ptr)->QSpacerItem::setGeometry(*static_cast<QRect*>(r));
}

void* QSpacerItem_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSpacerItem*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSpacerItem_SizeHintDefault(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QSpacerItem*>(ptr)->QSpacerItem::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSpacerItem_SizePolicy(void* ptr)
{
	return new QSizePolicy(static_cast<QSpacerItem*>(ptr)->sizePolicy());
}

void QSpacerItem_DestroyQSpacerItem(void* ptr)
{
	static_cast<QSpacerItem*>(ptr)->~QSpacerItem();
}

void QSpacerItem_DestroyQSpacerItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQSpinBox: public QSpinBox
{
public:
	MyQSpinBox(QWidget *parent = Q_NULLPTR) : QSpinBox(parent) {QSpinBox_QSpinBox_QRegisterMetaType();};
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void fixup(QString & input) const { QByteArray* t140f86 = new QByteArray(input.toUtf8()); QtWidgets_PackedString inputPacked = { const_cast<char*>(t140f86->prepend("WHITESPACE").constData()+10), t140f86->size()-10, t140f86 };callbackQAbstractSpinBox_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
	void setValue(int val) { callbackQSpinBox_SetValue(this, val); };
	QString textFromValue(int value) const { return ({ QtWidgets_PackedString tempVal = callbackQSpinBox_TextFromValue(const_cast<void*>(static_cast<const void*>(this)), value); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	QValidator::State validate(QString & text, int & pos) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };return static_cast<QValidator::State>(callbackQAbstractSpinBox_Validate(const_cast<void*>(static_cast<const void*>(this)), textPacked, pos)); };
	void Signal_ValueChanged(int i) { callbackQSpinBox_ValueChanged(this, i); };
	void Signal_ValueChanged2(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQSpinBox_ValueChanged2(this, textPacked); };
	int valueFromText(const QString & text) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };return callbackQSpinBox_ValueFromText(const_cast<void*>(static_cast<const void*>(this)), textPacked); };
	 ~MyQSpinBox() { callbackQSpinBox_DestroyQSpinBox(this); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	void clear() { callbackQAbstractSpinBox_Clear(this); };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_EditingFinished() { callbackQAbstractSpinBox_EditingFinished(this); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void selectAll() { callbackQAbstractSpinBox_SelectAll(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void stepBy(int steps) { callbackQAbstractSpinBox_StepBy(this, steps); };
	void stepDown() { callbackQAbstractSpinBox_StepDown(this); };
	QAbstractSpinBox::StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQAbstractSpinBox_StepEnabled(const_cast<void*>(static_cast<const void*>(this)))); };
	void stepUp() { callbackQAbstractSpinBox_StepUp(this); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QSpinBox*)
Q_DECLARE_METATYPE(MyQSpinBox*)

int QSpinBox_QSpinBox_QRegisterMetaType(){qRegisterMetaType<QSpinBox*>(); return qRegisterMetaType<MyQSpinBox*>();}

void* QSpinBox_NewQSpinBox(void* parent)
{
		return new MyQSpinBox(static_cast<QWidget*>(parent));
}

struct QtWidgets_PackedString QSpinBox_CleanText(void* ptr)
{
	return ({ QByteArray* t9d04b9 = new QByteArray(static_cast<QSpinBox*>(ptr)->cleanText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t9d04b9->prepend("WHITESPACE").constData()+10), t9d04b9->size()-10, t9d04b9 }; });
}

int QSpinBox_DisplayIntegerBase(void* ptr)
{
	return static_cast<QSpinBox*>(ptr)->displayIntegerBase();
}

int QSpinBox_Maximum(void* ptr)
{
	return static_cast<QSpinBox*>(ptr)->maximum();
}

int QSpinBox_Minimum(void* ptr)
{
	return static_cast<QSpinBox*>(ptr)->minimum();
}

struct QtWidgets_PackedString QSpinBox_Prefix(void* ptr)
{
	return ({ QByteArray* t9d23c1 = new QByteArray(static_cast<QSpinBox*>(ptr)->prefix().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t9d23c1->prepend("WHITESPACE").constData()+10), t9d23c1->size()-10, t9d23c1 }; });
}

void QSpinBox_SetDisplayIntegerBase(void* ptr, int base)
{
	static_cast<QSpinBox*>(ptr)->setDisplayIntegerBase(base);
}

void QSpinBox_SetMaximum(void* ptr, int max)
{
	static_cast<QSpinBox*>(ptr)->setMaximum(max);
}

void QSpinBox_SetMinimum(void* ptr, int min)
{
	static_cast<QSpinBox*>(ptr)->setMinimum(min);
}

void QSpinBox_SetPrefix(void* ptr, struct QtWidgets_PackedString prefix)
{
	static_cast<QSpinBox*>(ptr)->setPrefix(QString::fromUtf8(prefix.data, prefix.len));
}

void QSpinBox_SetRange(void* ptr, int minimum, int maximum)
{
	static_cast<QSpinBox*>(ptr)->setRange(minimum, maximum);
}

void QSpinBox_SetSingleStep(void* ptr, int val)
{
	static_cast<QSpinBox*>(ptr)->setSingleStep(val);
}

void QSpinBox_SetStepType(void* ptr, long long stepType)
{
	static_cast<QSpinBox*>(ptr)->setStepType(static_cast<QAbstractSpinBox::StepType>(stepType));
}

void QSpinBox_SetSuffix(void* ptr, struct QtWidgets_PackedString suffix)
{
	static_cast<QSpinBox*>(ptr)->setSuffix(QString::fromUtf8(suffix.data, suffix.len));
}

void QSpinBox_SetValue(void* ptr, int val)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setValue", Q_ARG(int, val));
}

void QSpinBox_SetValueDefault(void* ptr, int val)
{
		static_cast<QSpinBox*>(ptr)->QSpinBox::setValue(val);
}

int QSpinBox_SingleStep(void* ptr)
{
	return static_cast<QSpinBox*>(ptr)->singleStep();
}

long long QSpinBox_StepType(void* ptr)
{
	return static_cast<QSpinBox*>(ptr)->stepType();
}

struct QtWidgets_PackedString QSpinBox_Suffix(void* ptr)
{
	return ({ QByteArray* t38bf82 = new QByteArray(static_cast<QSpinBox*>(ptr)->suffix().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t38bf82->prepend("WHITESPACE").constData()+10), t38bf82->size()-10, t38bf82 }; });
}

struct QtWidgets_PackedString QSpinBox_TextFromValue(void* ptr, int value)
{
	return ({ QByteArray* tf53a0d = new QByteArray(static_cast<QSpinBox*>(ptr)->textFromValue(value).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tf53a0d->prepend("WHITESPACE").constData()+10), tf53a0d->size()-10, tf53a0d }; });
}

struct QtWidgets_PackedString QSpinBox_TextFromValueDefault(void* ptr, int value)
{
		return ({ QByteArray* td11815 = new QByteArray(static_cast<QSpinBox*>(ptr)->QSpinBox::textFromValue(value).toUtf8()); QtWidgets_PackedString { const_cast<char*>(td11815->prepend("WHITESPACE").constData()+10), td11815->size()-10, td11815 }; });
}

int QSpinBox_Value(void* ptr)
{
	return static_cast<QSpinBox*>(ptr)->value();
}

void QSpinBox_ConnectValueChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QSpinBox*>(ptr), static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), static_cast<MyQSpinBox*>(ptr), static_cast<void (MyQSpinBox::*)(int)>(&MyQSpinBox::Signal_ValueChanged), static_cast<Qt::ConnectionType>(t));
}

void QSpinBox_DisconnectValueChanged(void* ptr)
{
	QObject::disconnect(static_cast<QSpinBox*>(ptr), static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), static_cast<MyQSpinBox*>(ptr), static_cast<void (MyQSpinBox::*)(int)>(&MyQSpinBox::Signal_ValueChanged));
}

void QSpinBox_ValueChanged(void* ptr, int i)
{
	static_cast<QSpinBox*>(ptr)->valueChanged(i);
}

void QSpinBox_ConnectValueChanged2(void* ptr, long long t)
{
	QObject::connect(static_cast<QSpinBox*>(ptr), static_cast<void (QSpinBox::*)(const QString &)>(&QSpinBox::valueChanged), static_cast<MyQSpinBox*>(ptr), static_cast<void (MyQSpinBox::*)(const QString &)>(&MyQSpinBox::Signal_ValueChanged2), static_cast<Qt::ConnectionType>(t));
}

void QSpinBox_DisconnectValueChanged2(void* ptr)
{
	QObject::disconnect(static_cast<QSpinBox*>(ptr), static_cast<void (QSpinBox::*)(const QString &)>(&QSpinBox::valueChanged), static_cast<MyQSpinBox*>(ptr), static_cast<void (MyQSpinBox::*)(const QString &)>(&MyQSpinBox::Signal_ValueChanged2));
}

void QSpinBox_ValueChanged2(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QSpinBox*>(ptr)->valueChanged(QString::fromUtf8(text.data, text.len));
}

int QSpinBox_ValueFromText(void* ptr, struct QtWidgets_PackedString text)
{
	return static_cast<QSpinBox*>(ptr)->valueFromText(QString::fromUtf8(text.data, text.len));
}

int QSpinBox_ValueFromTextDefault(void* ptr, struct QtWidgets_PackedString text)
{
		return static_cast<QSpinBox*>(ptr)->QSpinBox::valueFromText(QString::fromUtf8(text.data, text.len));
}

void QSpinBox_DestroyQSpinBox(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->~QSpinBox();
}

void QSpinBox_DestroyQSpinBoxDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQSplashScreen: public QSplashScreen
{
public:
	MyQSplashScreen(const QPixmap &pixmap = QPixmap(), Qt::WindowFlags ff = Qt::WindowFlags()) : QSplashScreen(pixmap, ff) {QSplashScreen_QSplashScreen_QRegisterMetaType();};
	MyQSplashScreen(QWidget *parent, const QPixmap &pixmap = QPixmap(), Qt::WindowFlags ff = Qt::WindowFlags()) : QSplashScreen(parent, pixmap, ff) {QSplashScreen_QSplashScreen_QRegisterMetaType();};
	void clearMessage() { callbackQSplashScreen_ClearMessage(this); };
	void drawContents(QPainter * painter) { callbackQSplashScreen_DrawContents(this, painter); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void Signal_MessageChanged(const QString & message) { QByteArray* t6f9b9a = new QByteArray(message.toUtf8()); QtWidgets_PackedString messagePacked = { const_cast<char*>(t6f9b9a->prepend("WHITESPACE").constData()+10), t6f9b9a->size()-10, t6f9b9a };callbackQSplashScreen_MessageChanged(this, messagePacked); };
	void mousePressEvent(QMouseEvent * vqm) { callbackQWidget_MousePressEvent(this, vqm); };
	void showMessage(const QString & message, int alignment, const QColor & color) { QByteArray* t6f9b9a = new QByteArray(message.toUtf8()); QtWidgets_PackedString messagePacked = { const_cast<char*>(t6f9b9a->prepend("WHITESPACE").constData()+10), t6f9b9a->size()-10, t6f9b9a };callbackQSplashScreen_ShowMessage(this, messagePacked, alignment, const_cast<QColor*>(&color)); };
	 ~MyQSplashScreen() { callbackQSplashScreen_DestroyQSplashScreen(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QSplashScreen*)
Q_DECLARE_METATYPE(MyQSplashScreen*)

int QSplashScreen_QSplashScreen_QRegisterMetaType(){qRegisterMetaType<QSplashScreen*>(); return qRegisterMetaType<MyQSplashScreen*>();}

void* QSplashScreen_NewQSplashScreen(void* pixmap, long long ff)
{
	return new MyQSplashScreen(*static_cast<QPixmap*>(pixmap), static_cast<Qt::WindowType>(ff));
}

void* QSplashScreen_NewQSplashScreen2(void* parent, void* pixmap, long long ff)
{
		return new MyQSplashScreen(static_cast<QWidget*>(parent), *static_cast<QPixmap*>(pixmap), static_cast<Qt::WindowType>(ff));
}

void QSplashScreen_ClearMessage(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "clearMessage");
}

void QSplashScreen_ClearMessageDefault(void* ptr)
{
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::clearMessage();
}

void QSplashScreen_DrawContents(void* ptr, void* painter)
{
	static_cast<QSplashScreen*>(ptr)->drawContents(static_cast<QPainter*>(painter));
}

void QSplashScreen_DrawContentsDefault(void* ptr, void* painter)
{
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::drawContents(static_cast<QPainter*>(painter));
}

void QSplashScreen_Finish(void* ptr, void* mainWin)
{
		static_cast<QSplashScreen*>(ptr)->finish(static_cast<QWidget*>(mainWin));
}

struct QtWidgets_PackedString QSplashScreen_Message(void* ptr)
{
	return ({ QByteArray* tbae626 = new QByteArray(static_cast<QSplashScreen*>(ptr)->message().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tbae626->prepend("WHITESPACE").constData()+10), tbae626->size()-10, tbae626 }; });
}

void QSplashScreen_ConnectMessageChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QSplashScreen*>(ptr), static_cast<void (QSplashScreen::*)(const QString &)>(&QSplashScreen::messageChanged), static_cast<MyQSplashScreen*>(ptr), static_cast<void (MyQSplashScreen::*)(const QString &)>(&MyQSplashScreen::Signal_MessageChanged), static_cast<Qt::ConnectionType>(t));
}

void QSplashScreen_DisconnectMessageChanged(void* ptr)
{
	QObject::disconnect(static_cast<QSplashScreen*>(ptr), static_cast<void (QSplashScreen::*)(const QString &)>(&QSplashScreen::messageChanged), static_cast<MyQSplashScreen*>(ptr), static_cast<void (MyQSplashScreen::*)(const QString &)>(&MyQSplashScreen::Signal_MessageChanged));
}

void QSplashScreen_MessageChanged(void* ptr, struct QtWidgets_PackedString message)
{
	static_cast<QSplashScreen*>(ptr)->messageChanged(QString::fromUtf8(message.data, message.len));
}

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

void QSplashScreen_Repaint(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->repaint();
}

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

void QSplashScreen_ShowMessage(void* ptr, struct QtWidgets_PackedString message, int alignment, void* color)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "showMessage", Q_ARG(const QString, QString::fromUtf8(message.data, message.len)), Q_ARG(int, alignment), Q_ARG(const QColor, *static_cast<QColor*>(color)));
}

void QSplashScreen_ShowMessageDefault(void* ptr, struct QtWidgets_PackedString message, int alignment, void* color)
{
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::showMessage(QString::fromUtf8(message.data, message.len), alignment, *static_cast<QColor*>(color));
}

void QSplashScreen_DestroyQSplashScreen(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->~QSplashScreen();
}

void QSplashScreen_DestroyQSplashScreenDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQSplitter: public QSplitter
{
public:
	MyQSplitter(QWidget *parent = Q_NULLPTR) : QSplitter(parent) {QSplitter_QSplitter_QRegisterMetaType();};
	MyQSplitter(Qt::Orientation orientation, QWidget *parent = Q_NULLPTR) : QSplitter(orientation, parent) {QSplitter_QSplitter_QRegisterMetaType();};
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void childEvent(QChildEvent * c) { callbackQWidget_ChildEvent(this, c); };
	QSplitterHandle * createHandle() { return static_cast<QSplitterHandle*>(callbackQSplitter_CreateHandle(this)); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void resizeEvent(QResizeEvent * vqr) { callbackQWidget_ResizeEvent(this, vqr); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_SplitterMoved(int pos, int index) { callbackQSplitter_SplitterMoved(this, pos, index); };
	 ~MyQSplitter() { callbackQSplitter_DestroyQSplitter(this); };
	void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QSplitter*)
Q_DECLARE_METATYPE(MyQSplitter*)

int QSplitter_QSplitter_QRegisterMetaType(){qRegisterMetaType<QSplitter*>(); return qRegisterMetaType<MyQSplitter*>();}

void* QSplitter_NewQSplitter(void* parent)
{
		return new MyQSplitter(static_cast<QWidget*>(parent));
}

void* QSplitter_NewQSplitter2(long long orientation, void* parent)
{
		return new MyQSplitter(static_cast<Qt::Orientation>(orientation), static_cast<QWidget*>(parent));
}

void QSplitter_AddWidget(void* ptr, void* widget)
{
		static_cast<QSplitter*>(ptr)->addWidget(static_cast<QWidget*>(widget));
}

char QSplitter_ChildrenCollapsible(void* ptr)
{
	return static_cast<QSplitter*>(ptr)->childrenCollapsible();
}

int QSplitter_ClosestLegalPosition(void* ptr, int pos, int index)
{
	return static_cast<QSplitter*>(ptr)->closestLegalPosition(pos, index);
}

int QSplitter_Count(void* ptr)
{
	return static_cast<QSplitter*>(ptr)->count();
}

void* QSplitter_CreateHandle(void* ptr)
{
	return static_cast<QSplitter*>(ptr)->createHandle();
}

void* QSplitter_CreateHandleDefault(void* ptr)
{
		return static_cast<QSplitter*>(ptr)->QSplitter::createHandle();
}

void QSplitter_GetRange(void* ptr, int index, int min, int max)
{
	static_cast<QSplitter*>(ptr)->getRange(index, &min, &max);
}

void* QSplitter_Handle(void* ptr, int index)
{
	return static_cast<QSplitter*>(ptr)->handle(index);
}

int QSplitter_HandleWidth(void* ptr)
{
	return static_cast<QSplitter*>(ptr)->handleWidth();
}

int QSplitter_IndexOf(void* ptr, void* widget)
{
		return static_cast<QSplitter*>(ptr)->indexOf(static_cast<QWidget*>(widget));
}

void QSplitter_InsertWidget(void* ptr, int index, void* widget)
{
		static_cast<QSplitter*>(ptr)->insertWidget(index, static_cast<QWidget*>(widget));
}

char QSplitter_IsCollapsible(void* ptr, int index)
{
	return static_cast<QSplitter*>(ptr)->isCollapsible(index);
}

void QSplitter_MoveSplitter(void* ptr, int pos, int index)
{
	static_cast<QSplitter*>(ptr)->moveSplitter(pos, index);
}

char QSplitter_OpaqueResize(void* ptr)
{
	return static_cast<QSplitter*>(ptr)->opaqueResize();
}

long long QSplitter_Orientation(void* ptr)
{
	return static_cast<QSplitter*>(ptr)->orientation();
}

void QSplitter_Refresh(void* ptr)
{
	static_cast<QSplitter*>(ptr)->refresh();
}

void* QSplitter_ReplaceWidget(void* ptr, int index, void* widget)
{
		return static_cast<QSplitter*>(ptr)->replaceWidget(index, static_cast<QWidget*>(widget));
}

char QSplitter_RestoreState(void* ptr, void* state)
{
	return static_cast<QSplitter*>(ptr)->restoreState(*static_cast<QByteArray*>(state));
}

void* QSplitter_SaveState(void* ptr)
{
	return new QByteArray(static_cast<QSplitter*>(ptr)->saveState());
}

void QSplitter_SetChildrenCollapsible(void* ptr, char vbo)
{
	static_cast<QSplitter*>(ptr)->setChildrenCollapsible(vbo != 0);
}

void QSplitter_SetCollapsible(void* ptr, int index, char collapse)
{
	static_cast<QSplitter*>(ptr)->setCollapsible(index, collapse != 0);
}

void QSplitter_SetHandleWidth(void* ptr, int vin)
{
	static_cast<QSplitter*>(ptr)->setHandleWidth(vin);
}

void QSplitter_SetOpaqueResize(void* ptr, char opaque)
{
	static_cast<QSplitter*>(ptr)->setOpaqueResize(opaque != 0);
}

void QSplitter_SetOrientation(void* ptr, long long vqt)
{
	static_cast<QSplitter*>(ptr)->setOrientation(static_cast<Qt::Orientation>(vqt));
}

void QSplitter_SetRubberBand(void* ptr, int pos)
{
	static_cast<QSplitter*>(ptr)->setRubberBand(pos);
}

void QSplitter_SetSizes(void* ptr, void* list)
{
	static_cast<QSplitter*>(ptr)->setSizes(*static_cast<QList<int>*>(list));
}

void QSplitter_SetStretchFactor(void* ptr, int index, int stretch)
{
	static_cast<QSplitter*>(ptr)->setStretchFactor(index, stretch);
}

struct QtWidgets_PackedList QSplitter_Sizes(void* ptr)
{
	return ({ QList<int>* tmpValue8bae9b = new QList<int>(static_cast<QSplitter*>(ptr)->sizes()); QtWidgets_PackedList { tmpValue8bae9b, tmpValue8bae9b->size() }; });
}

void QSplitter_ConnectSplitterMoved(void* ptr, long long t)
{
	QObject::connect(static_cast<QSplitter*>(ptr), static_cast<void (QSplitter::*)(int, int)>(&QSplitter::splitterMoved), static_cast<MyQSplitter*>(ptr), static_cast<void (MyQSplitter::*)(int, int)>(&MyQSplitter::Signal_SplitterMoved), static_cast<Qt::ConnectionType>(t));
}

void QSplitter_DisconnectSplitterMoved(void* ptr)
{
	QObject::disconnect(static_cast<QSplitter*>(ptr), static_cast<void (QSplitter::*)(int, int)>(&QSplitter::splitterMoved), static_cast<MyQSplitter*>(ptr), static_cast<void (MyQSplitter::*)(int, int)>(&MyQSplitter::Signal_SplitterMoved));
}

void QSplitter_SplitterMoved(void* ptr, int pos, int index)
{
	static_cast<QSplitter*>(ptr)->splitterMoved(pos, index);
}

void* QSplitter_Widget(void* ptr, int index)
{
	return static_cast<QSplitter*>(ptr)->widget(index);
}

void QSplitter_DestroyQSplitter(void* ptr)
{
	static_cast<QSplitter*>(ptr)->~QSplitter();
}

void QSplitter_DestroyQSplitterDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

int QSplitter___setSizes_list_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

int QSplitter___sizes_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

class MyQSplitterHandle: public QSplitterHandle
{
public:
	MyQSplitterHandle(Qt::Orientation orientation, QSplitter *parent) : QSplitterHandle(orientation, parent) {QSplitterHandle_QSplitterHandle_QRegisterMetaType();};
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQSplitterHandle() { callbackQSplitterHandle_DestroyQSplitterHandle(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QSplitterHandle*)
Q_DECLARE_METATYPE(MyQSplitterHandle*)

int QSplitterHandle_QSplitterHandle_QRegisterMetaType(){qRegisterMetaType<QSplitterHandle*>(); return qRegisterMetaType<MyQSplitterHandle*>();}

void* QSplitterHandle_NewQSplitterHandle(long long orientation, void* parent)
{
	return new MyQSplitterHandle(static_cast<Qt::Orientation>(orientation), static_cast<QSplitter*>(parent));
}

int QSplitterHandle_ClosestLegalPosition(void* ptr, int pos)
{
	return static_cast<QSplitterHandle*>(ptr)->closestLegalPosition(pos);
}

void QSplitterHandle_MoveSplitter(void* ptr, int pos)
{
	static_cast<QSplitterHandle*>(ptr)->moveSplitter(pos);
}

char QSplitterHandle_OpaqueResize(void* ptr)
{
	return static_cast<QSplitterHandle*>(ptr)->opaqueResize();
}

long long QSplitterHandle_Orientation(void* ptr)
{
	return static_cast<QSplitterHandle*>(ptr)->orientation();
}

void QSplitterHandle_SetOrientation(void* ptr, long long orientation)
{
	static_cast<QSplitterHandle*>(ptr)->setOrientation(static_cast<Qt::Orientation>(orientation));
}

void* QSplitterHandle_Splitter(void* ptr)
{
	return static_cast<QSplitterHandle*>(ptr)->splitter();
}

void QSplitterHandle_DestroyQSplitterHandle(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->~QSplitterHandle();
}

void QSplitterHandle_DestroyQSplitterHandleDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQStackedLayout: public QStackedLayout
{
public:
	MyQStackedLayout() : QStackedLayout() {QStackedLayout_QStackedLayout_QRegisterMetaType();};
	MyQStackedLayout(QWidget *parent) : QStackedLayout(parent) {QStackedLayout_QStackedLayout_QRegisterMetaType();};
	MyQStackedLayout(QLayout *parentLayout) : QStackedLayout(parentLayout) {QStackedLayout_QStackedLayout_QRegisterMetaType();};
	void addItem(QLayoutItem * item) { callbackQStackedLayout_AddItem(this, item); };
	int count() const { return callbackQStackedLayout_Count(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_CurrentChanged(int index) { callbackQStackedLayout_CurrentChanged(this, index); };
	bool hasHeightForWidth() const { return callbackQLayoutItem_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int width) const { return callbackQLayoutItem_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), width); };
	QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQStackedLayout_ItemAt(const_cast<void*>(static_cast<const void*>(this)), index)); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQLayout_MinimumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	void setCurrentIndex(int index) { callbackQStackedLayout_SetCurrentIndex(this, index); };
	void setCurrentWidget(QWidget * widget) { callbackQStackedLayout_SetCurrentWidget(this, widget); };
	void setGeometry(const QRect & rect) { callbackQLayout_SetGeometry(this, const_cast<QRect*>(&rect)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQStackedLayout_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQStackedLayout_TakeAt(this, index)); };
	void Signal_WidgetRemoved(int index) { callbackQStackedLayout_WidgetRemoved(this, index); };
	 ~MyQStackedLayout() { callbackQStackedLayout_DestroyQStackedLayout(this); };
	void childEvent(QChildEvent * e) { callbackQLayout_ChildEvent(this, e); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayoutItem_ControlTypes(const_cast<void*>(static_cast<const void*>(this)))); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQLayout_ExpandingDirections(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQLayout_Geometry(const_cast<void*>(static_cast<const void*>(this)))); };
	int indexOf(QWidget * widget) const { return callbackQLayout_IndexOf(const_cast<void*>(static_cast<const void*>(this)), widget); };
	void invalidate() { callbackQLayoutItem_Invalidate(this); };
	bool isEmpty() const { return callbackQLayout_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QLayout * layout() { return static_cast<QLayout*>(callbackQLayoutItem_Layout(this)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQLayout_MaximumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	void connectNotify(const QMetaMethod & sign) { callbackQLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQLayout_CustomEvent(this, event); };
	void deleteLater() { callbackQLayout_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQLayout_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQLayout_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQLayout_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLayout_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQLayout_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQLayout_TimerEvent(this, event); };
	int minimumHeightForWidth(int w) const { return callbackQLayoutItem_MinimumHeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayoutItem_SpacerItem(this)); };
};

Q_DECLARE_METATYPE(QStackedLayout*)
Q_DECLARE_METATYPE(MyQStackedLayout*)

int QStackedLayout_QStackedLayout_QRegisterMetaType(){qRegisterMetaType<QStackedLayout*>(); return qRegisterMetaType<MyQStackedLayout*>();}

void* QStackedLayout_NewQStackedLayout()
{
	return new MyQStackedLayout();
}

void* QStackedLayout_NewQStackedLayout2(void* parent)
{
		return new MyQStackedLayout(static_cast<QWidget*>(parent));
}

void* QStackedLayout_NewQStackedLayout3(void* parentLayout)
{
		return new MyQStackedLayout(static_cast<QLayout*>(parentLayout));
}

void QStackedLayout_AddItem(void* ptr, void* item)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
		static_cast<QStackedLayout*>(ptr)->addItem(static_cast<QLayout*>(item));
	} else {
		static_cast<QStackedLayout*>(ptr)->addItem(static_cast<QLayoutItem*>(item));
	}
}

void QStackedLayout_AddItemDefault(void* ptr, void* item)
{
	if (dynamic_cast<QLayout*>(static_cast<QObject*>(item))) {
		static_cast<QStackedLayout*>(ptr)->QStackedLayout::addItem(static_cast<QLayout*>(item));
	} else {
		static_cast<QStackedLayout*>(ptr)->QStackedLayout::addItem(static_cast<QLayoutItem*>(item));
	}
}

int QStackedLayout_AddWidget(void* ptr, void* widget)
{
		return static_cast<QStackedLayout*>(ptr)->addWidget(static_cast<QWidget*>(widget));
}

int QStackedLayout_Count(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->count();
}

int QStackedLayout_CountDefault(void* ptr)
{
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::count();
}

void QStackedLayout_ConnectCurrentChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QStackedLayout*>(ptr), static_cast<void (QStackedLayout::*)(int)>(&QStackedLayout::currentChanged), static_cast<MyQStackedLayout*>(ptr), static_cast<void (MyQStackedLayout::*)(int)>(&MyQStackedLayout::Signal_CurrentChanged), static_cast<Qt::ConnectionType>(t));
}

void QStackedLayout_DisconnectCurrentChanged(void* ptr)
{
	QObject::disconnect(static_cast<QStackedLayout*>(ptr), static_cast<void (QStackedLayout::*)(int)>(&QStackedLayout::currentChanged), static_cast<MyQStackedLayout*>(ptr), static_cast<void (MyQStackedLayout::*)(int)>(&MyQStackedLayout::Signal_CurrentChanged));
}

void QStackedLayout_CurrentChanged(void* ptr, int index)
{
	static_cast<QStackedLayout*>(ptr)->currentChanged(index);
}

int QStackedLayout_CurrentIndex(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->currentIndex();
}

void* QStackedLayout_CurrentWidget(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->currentWidget();
}

int QStackedLayout_InsertWidget(void* ptr, int index, void* widget)
{
		return static_cast<QStackedLayout*>(ptr)->insertWidget(index, static_cast<QWidget*>(widget));
}

void* QStackedLayout_ItemAt(void* ptr, int index)
{
	return static_cast<QStackedLayout*>(ptr)->itemAt(index);
}

void* QStackedLayout_ItemAtDefault(void* ptr, int index)
{
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::itemAt(index);
}

void QStackedLayout_SetCurrentIndex(void* ptr, int index)
{
	QMetaObject::invokeMethod(static_cast<QStackedLayout*>(ptr), "setCurrentIndex", Q_ARG(int, index));
}

void QStackedLayout_SetCurrentIndexDefault(void* ptr, int index)
{
		static_cast<QStackedLayout*>(ptr)->QStackedLayout::setCurrentIndex(index);
}

void QStackedLayout_SetCurrentWidget(void* ptr, void* widget)
{
		QMetaObject::invokeMethod(static_cast<QStackedLayout*>(ptr), "setCurrentWidget", Q_ARG(QWidget*, static_cast<QWidget*>(widget)));
}

void QStackedLayout_SetCurrentWidgetDefault(void* ptr, void* widget)
{
		static_cast<QStackedLayout*>(ptr)->QStackedLayout::setCurrentWidget(static_cast<QWidget*>(widget));
}

void QStackedLayout_SetStackingMode(void* ptr, long long stackingMode)
{
	static_cast<QStackedLayout*>(ptr)->setStackingMode(static_cast<QStackedLayout::StackingMode>(stackingMode));
}

void* QStackedLayout_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStackedLayout*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QStackedLayout_SizeHintDefault(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QStackedLayout*>(ptr)->QStackedLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

long long QStackedLayout_StackingMode(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->stackingMode();
}

void* QStackedLayout_TakeAt(void* ptr, int index)
{
	return static_cast<QStackedLayout*>(ptr)->takeAt(index);
}

void* QStackedLayout_TakeAtDefault(void* ptr, int index)
{
		return static_cast<QStackedLayout*>(ptr)->QStackedLayout::takeAt(index);
}

void* QStackedLayout_Widget(void* ptr, int index)
{
	return static_cast<QStackedLayout*>(ptr)->widget(index);
}

void QStackedLayout_ConnectWidgetRemoved(void* ptr, long long t)
{
	QObject::connect(static_cast<QStackedLayout*>(ptr), static_cast<void (QStackedLayout::*)(int)>(&QStackedLayout::widgetRemoved), static_cast<MyQStackedLayout*>(ptr), static_cast<void (MyQStackedLayout::*)(int)>(&MyQStackedLayout::Signal_WidgetRemoved), static_cast<Qt::ConnectionType>(t));
}

void QStackedLayout_DisconnectWidgetRemoved(void* ptr)
{
	QObject::disconnect(static_cast<QStackedLayout*>(ptr), static_cast<void (QStackedLayout::*)(int)>(&QStackedLayout::widgetRemoved), static_cast<MyQStackedLayout*>(ptr), static_cast<void (MyQStackedLayout::*)(int)>(&MyQStackedLayout::Signal_WidgetRemoved));
}

void QStackedLayout_WidgetRemoved(void* ptr, int index)
{
	static_cast<QStackedLayout*>(ptr)->widgetRemoved(index);
}

void QStackedLayout_DestroyQStackedLayout(void* ptr)
{
	static_cast<QStackedLayout*>(ptr)->~QStackedLayout();
}

void QStackedLayout_DestroyQStackedLayoutDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQStackedWidget: public QStackedWidget
{
public:
	MyQStackedWidget(QWidget *parent = Q_NULLPTR) : QStackedWidget(parent) {QStackedWidget_QStackedWidget_QRegisterMetaType();};
	void Signal_CurrentChanged(int index) { callbackQStackedWidget_CurrentChanged(this, index); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void setCurrentIndex(int index) { callbackQStackedWidget_SetCurrentIndex(this, index); };
	void setCurrentWidget(QWidget * widget) { callbackQStackedWidget_SetCurrentWidget(this, widget); };
	void Signal_WidgetRemoved(int index) { callbackQStackedWidget_WidgetRemoved(this, index); };
	 ~MyQStackedWidget() { callbackQStackedWidget_DestroyQStackedWidget(this); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QStackedWidget*)
Q_DECLARE_METATYPE(MyQStackedWidget*)

int QStackedWidget_QStackedWidget_QRegisterMetaType(){qRegisterMetaType<QStackedWidget*>(); return qRegisterMetaType<MyQStackedWidget*>();}

void* QStackedWidget_NewQStackedWidget(void* parent)
{
		return new MyQStackedWidget(static_cast<QWidget*>(parent));
}

int QStackedWidget_AddWidget(void* ptr, void* widget)
{
		return static_cast<QStackedWidget*>(ptr)->addWidget(static_cast<QWidget*>(widget));
}

int QStackedWidget_Count(void* ptr)
{
	return static_cast<QStackedWidget*>(ptr)->count();
}

void QStackedWidget_ConnectCurrentChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QStackedWidget*>(ptr), static_cast<void (QStackedWidget::*)(int)>(&QStackedWidget::currentChanged), static_cast<MyQStackedWidget*>(ptr), static_cast<void (MyQStackedWidget::*)(int)>(&MyQStackedWidget::Signal_CurrentChanged), static_cast<Qt::ConnectionType>(t));
}

void QStackedWidget_DisconnectCurrentChanged(void* ptr)
{
	QObject::disconnect(static_cast<QStackedWidget*>(ptr), static_cast<void (QStackedWidget::*)(int)>(&QStackedWidget::currentChanged), static_cast<MyQStackedWidget*>(ptr), static_cast<void (MyQStackedWidget::*)(int)>(&MyQStackedWidget::Signal_CurrentChanged));
}

void QStackedWidget_CurrentChanged(void* ptr, int index)
{
	static_cast<QStackedWidget*>(ptr)->currentChanged(index);
}

int QStackedWidget_CurrentIndex(void* ptr)
{
	return static_cast<QStackedWidget*>(ptr)->currentIndex();
}

void* QStackedWidget_CurrentWidget(void* ptr)
{
	return static_cast<QStackedWidget*>(ptr)->currentWidget();
}

int QStackedWidget_IndexOf(void* ptr, void* widget)
{
		return static_cast<QStackedWidget*>(ptr)->indexOf(static_cast<QWidget*>(widget));
}

int QStackedWidget_InsertWidget(void* ptr, int index, void* widget)
{
		return static_cast<QStackedWidget*>(ptr)->insertWidget(index, static_cast<QWidget*>(widget));
}

void QStackedWidget_RemoveWidget(void* ptr, void* widget)
{
		static_cast<QStackedWidget*>(ptr)->removeWidget(static_cast<QWidget*>(widget));
}

void QStackedWidget_SetCurrentIndex(void* ptr, int index)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setCurrentIndex", Q_ARG(int, index));
}

void QStackedWidget_SetCurrentIndexDefault(void* ptr, int index)
{
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::setCurrentIndex(index);
}

void QStackedWidget_SetCurrentWidget(void* ptr, void* widget)
{
		QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setCurrentWidget", Q_ARG(QWidget*, static_cast<QWidget*>(widget)));
}

void QStackedWidget_SetCurrentWidgetDefault(void* ptr, void* widget)
{
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::setCurrentWidget(static_cast<QWidget*>(widget));
}

void* QStackedWidget_Widget(void* ptr, int index)
{
	return static_cast<QStackedWidget*>(ptr)->widget(index);
}

void QStackedWidget_ConnectWidgetRemoved(void* ptr, long long t)
{
	QObject::connect(static_cast<QStackedWidget*>(ptr), static_cast<void (QStackedWidget::*)(int)>(&QStackedWidget::widgetRemoved), static_cast<MyQStackedWidget*>(ptr), static_cast<void (MyQStackedWidget::*)(int)>(&MyQStackedWidget::Signal_WidgetRemoved), static_cast<Qt::ConnectionType>(t));
}

void QStackedWidget_DisconnectWidgetRemoved(void* ptr)
{
	QObject::disconnect(static_cast<QStackedWidget*>(ptr), static_cast<void (QStackedWidget::*)(int)>(&QStackedWidget::widgetRemoved), static_cast<MyQStackedWidget*>(ptr), static_cast<void (MyQStackedWidget::*)(int)>(&MyQStackedWidget::Signal_WidgetRemoved));
}

void QStackedWidget_WidgetRemoved(void* ptr, int index)
{
	static_cast<QStackedWidget*>(ptr)->widgetRemoved(index);
}

void QStackedWidget_DestroyQStackedWidget(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->~QStackedWidget();
}

void QStackedWidget_DestroyQStackedWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQStatusBar: public QStatusBar
{
public:
	MyQStatusBar(QWidget *parent = Q_NULLPTR) : QStatusBar(parent) {QStatusBar_QStatusBar_QRegisterMetaType();};
	void clearMessage() { callbackQStatusBar_ClearMessage(this); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void Signal_MessageChanged(const QString & message) { QByteArray* t6f9b9a = new QByteArray(message.toUtf8()); QtWidgets_PackedString messagePacked = { const_cast<char*>(t6f9b9a->prepend("WHITESPACE").constData()+10), t6f9b9a->size()-10, t6f9b9a };callbackQStatusBar_MessageChanged(this, messagePacked); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void showEvent(QShowEvent * vqs) { callbackQWidget_ShowEvent(this, vqs); };
	void showMessage(const QString & message, int timeout) { QByteArray* t6f9b9a = new QByteArray(message.toUtf8()); QtWidgets_PackedString messagePacked = { const_cast<char*>(t6f9b9a->prepend("WHITESPACE").constData()+10), t6f9b9a->size()-10, t6f9b9a };callbackQStatusBar_ShowMessage(this, messagePacked, timeout); };
	 ~MyQStatusBar() { callbackQStatusBar_DestroyQStatusBar(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QStatusBar*)
Q_DECLARE_METATYPE(MyQStatusBar*)

int QStatusBar_QStatusBar_QRegisterMetaType(){qRegisterMetaType<QStatusBar*>(); return qRegisterMetaType<MyQStatusBar*>();}

void* QStatusBar_NewQStatusBar(void* parent)
{
		return new MyQStatusBar(static_cast<QWidget*>(parent));
}

void QStatusBar_AddPermanentWidget(void* ptr, void* widget, int stretch)
{
		static_cast<QStatusBar*>(ptr)->addPermanentWidget(static_cast<QWidget*>(widget), stretch);
}

void QStatusBar_AddWidget(void* ptr, void* widget, int stretch)
{
		static_cast<QStatusBar*>(ptr)->addWidget(static_cast<QWidget*>(widget), stretch);
}

void QStatusBar_ClearMessage(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "clearMessage");
}

void QStatusBar_ClearMessageDefault(void* ptr)
{
		static_cast<QStatusBar*>(ptr)->QStatusBar::clearMessage();
}

struct QtWidgets_PackedString QStatusBar_CurrentMessage(void* ptr)
{
	return ({ QByteArray* t40367b = new QByteArray(static_cast<QStatusBar*>(ptr)->currentMessage().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t40367b->prepend("WHITESPACE").constData()+10), t40367b->size()-10, t40367b }; });
}

void QStatusBar_HideOrShow(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->hideOrShow();
}

int QStatusBar_InsertPermanentWidget(void* ptr, int index, void* widget, int stretch)
{
		return static_cast<QStatusBar*>(ptr)->insertPermanentWidget(index, static_cast<QWidget*>(widget), stretch);
}

int QStatusBar_InsertWidget(void* ptr, int index, void* widget, int stretch)
{
		return static_cast<QStatusBar*>(ptr)->insertWidget(index, static_cast<QWidget*>(widget), stretch);
}

char QStatusBar_IsSizeGripEnabled(void* ptr)
{
	return static_cast<QStatusBar*>(ptr)->isSizeGripEnabled();
}

void QStatusBar_ConnectMessageChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QStatusBar*>(ptr), static_cast<void (QStatusBar::*)(const QString &)>(&QStatusBar::messageChanged), static_cast<MyQStatusBar*>(ptr), static_cast<void (MyQStatusBar::*)(const QString &)>(&MyQStatusBar::Signal_MessageChanged), static_cast<Qt::ConnectionType>(t));
}

void QStatusBar_DisconnectMessageChanged(void* ptr)
{
	QObject::disconnect(static_cast<QStatusBar*>(ptr), static_cast<void (QStatusBar::*)(const QString &)>(&QStatusBar::messageChanged), static_cast<MyQStatusBar*>(ptr), static_cast<void (MyQStatusBar::*)(const QString &)>(&MyQStatusBar::Signal_MessageChanged));
}

void QStatusBar_MessageChanged(void* ptr, struct QtWidgets_PackedString message)
{
	static_cast<QStatusBar*>(ptr)->messageChanged(QString::fromUtf8(message.data, message.len));
}

void QStatusBar_Reformat(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->reformat();
}

void QStatusBar_RemoveWidget(void* ptr, void* widget)
{
		static_cast<QStatusBar*>(ptr)->removeWidget(static_cast<QWidget*>(widget));
}

void QStatusBar_SetSizeGripEnabled(void* ptr, char vbo)
{
	static_cast<QStatusBar*>(ptr)->setSizeGripEnabled(vbo != 0);
}

void QStatusBar_ShowMessage(void* ptr, struct QtWidgets_PackedString message, int timeout)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "showMessage", Q_ARG(const QString, QString::fromUtf8(message.data, message.len)), Q_ARG(int, timeout));
}

void QStatusBar_ShowMessageDefault(void* ptr, struct QtWidgets_PackedString message, int timeout)
{
		static_cast<QStatusBar*>(ptr)->QStatusBar::showMessage(QString::fromUtf8(message.data, message.len), timeout);
}

void QStatusBar_DestroyQStatusBar(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->~QStatusBar();
}

void QStatusBar_DestroyQStatusBarDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQStyle: public QStyle
{
public:
	MyQStyle() : QStyle() {QStyle_QStyle_QRegisterMetaType();};
	void drawComplexControl(QStyle::ComplexControl control, const QStyleOptionComplex * option, QPainter * painter, const QWidget * widget) const { callbackQStyle_DrawComplexControl(const_cast<void*>(static_cast<const void*>(this)), control, const_cast<QStyleOptionComplex*>(option), painter, const_cast<QWidget*>(widget)); };
	void drawControl(QStyle::ControlElement element, const QStyleOption * option, QPainter * painter, const QWidget * widget) const { callbackQStyle_DrawControl(const_cast<void*>(static_cast<const void*>(this)), element, const_cast<QStyleOption*>(option), painter, const_cast<QWidget*>(widget)); };
	void drawItemPixmap(QPainter * painter, const QRect & rectangle, int alignment, const QPixmap & pixmap) const { callbackQStyle_DrawItemPixmap(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QRect*>(&rectangle), alignment, const_cast<QPixmap*>(&pixmap)); };
	void drawItemText(QPainter * painter, const QRect & rectangle, int alignment, const QPalette & palette, bool enabled, const QString & text, QPalette::ColorRole textRole) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQStyle_DrawItemText(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QRect*>(&rectangle), alignment, const_cast<QPalette*>(&palette), enabled, textPacked, textRole); };
	void drawPrimitive(QStyle::PrimitiveElement element, const QStyleOption * option, QPainter * painter, const QWidget * widget) const { callbackQStyle_DrawPrimitive(const_cast<void*>(static_cast<const void*>(this)), element, const_cast<QStyleOption*>(option), painter, const_cast<QWidget*>(widget)); };
	QPixmap generatedIconPixmap(QIcon::Mode iconMode, const QPixmap & pixmap, const QStyleOption * option) const { return *static_cast<QPixmap*>(callbackQStyle_GeneratedIconPixmap(const_cast<void*>(static_cast<const void*>(this)), iconMode, const_cast<QPixmap*>(&pixmap), const_cast<QStyleOption*>(option))); };
	QStyle::SubControl hitTestComplexControl(QStyle::ComplexControl control, const QStyleOptionComplex * option, const QPoint & position, const QWidget * widget) const { return static_cast<QStyle::SubControl>(callbackQStyle_HitTestComplexControl(const_cast<void*>(static_cast<const void*>(this)), control, const_cast<QStyleOptionComplex*>(option), const_cast<QPoint*>(&position), const_cast<QWidget*>(widget))); };
	QRect itemPixmapRect(const QRect & rectangle, int alignment, const QPixmap & pixmap) const { return *static_cast<QRect*>(callbackQStyle_ItemPixmapRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QRect*>(&rectangle), alignment, const_cast<QPixmap*>(&pixmap))); };
	QRect itemTextRect(const QFontMetrics & metrics, const QRect & rectangle, int alignment, bool enabled, const QString & text) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };return *static_cast<QRect*>(callbackQStyle_ItemTextRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QFontMetrics*>(&metrics), const_cast<QRect*>(&rectangle), alignment, enabled, textPacked)); };
	int layoutSpacing(QSizePolicy::ControlType control1, QSizePolicy::ControlType control2, Qt::Orientation orientation, const QStyleOption * option, const QWidget * widget) const { return callbackQStyle_LayoutSpacing(const_cast<void*>(static_cast<const void*>(this)), control1, control2, orientation, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget)); };
	int pixelMetric(QStyle::PixelMetric metric, const QStyleOption * option, const QWidget * widget) const { return callbackQStyle_PixelMetric(const_cast<void*>(static_cast<const void*>(this)), metric, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget)); };
	void polish(QWidget * widget) { callbackQStyle_Polish(this, widget); };
	void polish(QApplication * application) { callbackQStyle_Polish2(this, application); };
	void polish(QPalette & palette) { callbackQStyle_Polish3(this, static_cast<QPalette*>(&palette)); };
	QSize sizeFromContents(QStyle::ContentsType ty, const QStyleOption * option, const QSize & contentsSize, const QWidget * widget) const { return *static_cast<QSize*>(callbackQStyle_SizeFromContents(const_cast<void*>(static_cast<const void*>(this)), ty, const_cast<QStyleOption*>(option), const_cast<QSize*>(&contentsSize), const_cast<QWidget*>(widget))); };
	QIcon standardIcon(QStyle::StandardPixmap standardIcon, const QStyleOption * option, const QWidget * widget) const { return *static_cast<QIcon*>(callbackQStyle_StandardIcon(const_cast<void*>(static_cast<const void*>(this)), standardIcon, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
	QPalette standardPalette() const { return *static_cast<QPalette*>(callbackQStyle_StandardPalette(const_cast<void*>(static_cast<const void*>(this)))); };
	int styleHint(QStyle::StyleHint hint, const QStyleOption * option, const QWidget * widget, QStyleHintReturn * returnData) const { return callbackQStyle_StyleHint(const_cast<void*>(static_cast<const void*>(this)), hint, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget), returnData); };
	QRect subControlRect(QStyle::ComplexControl control, const QStyleOptionComplex * option, QStyle::SubControl subControl, const QWidget * widget) const { return *static_cast<QRect*>(callbackQStyle_SubControlRect(const_cast<void*>(static_cast<const void*>(this)), control, const_cast<QStyleOptionComplex*>(option), subControl, const_cast<QWidget*>(widget))); };
	QRect subElementRect(QStyle::SubElement element, const QStyleOption * option, const QWidget * widget) const { return *static_cast<QRect*>(callbackQStyle_SubElementRect(const_cast<void*>(static_cast<const void*>(this)), element, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
	void unpolish(QWidget * widget) { callbackQStyle_Unpolish(this, widget); };
	void unpolish(QApplication * application) { callbackQStyle_Unpolish2(this, application); };
	 ~MyQStyle() { callbackQStyle_DestroyQStyle(this); };
	QPixmap standardPixmap(QStyle::StandardPixmap standardIcon, const QStyleOption * option, const QWidget * widget) const { return *static_cast<QPixmap*>(callbackQStyle_StandardPixmap(const_cast<void*>(static_cast<const void*>(this)), standardIcon, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
	void childEvent(QChildEvent * event) { callbackQStyle_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQStyle_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQStyle_CustomEvent(this, event); };
	void deleteLater() { callbackQStyle_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQStyle_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQStyle_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQStyle_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQStyle_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStyle_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQStyle_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQStyle_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QStyle*)
Q_DECLARE_METATYPE(MyQStyle*)

int QStyle_QStyle_QRegisterMetaType(){qRegisterMetaType<QStyle*>(); return qRegisterMetaType<MyQStyle*>();}

void* QStyle_NewQStyle2()
{
	return new MyQStyle();
}

void* QStyle_QStyle_AlignedRect(long long direction, long long alignment, void* size, void* rectangle)
{
	return ({ QRect tmpValue = QStyle::alignedRect(static_cast<Qt::LayoutDirection>(direction), static_cast<Qt::AlignmentFlag>(alignment), *static_cast<QSize*>(size), *static_cast<QRect*>(rectangle)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

int QStyle_CombinedLayoutSpacing(void* ptr, long long controls1, long long controls2, long long orientation, void* option, void* widget)
{
		return static_cast<QStyle*>(ptr)->combinedLayoutSpacing(static_cast<QSizePolicy::ControlType>(controls1), static_cast<QSizePolicy::ControlType>(controls2), static_cast<Qt::Orientation>(orientation), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget));
}

void QStyle_DrawComplexControl(void* ptr, long long control, void* option, void* painter, void* widget)
{
		static_cast<QStyle*>(ptr)->drawComplexControl(static_cast<QStyle::ComplexControl>(control), static_cast<QStyleOptionComplex*>(option), static_cast<QPainter*>(painter), static_cast<QWidget*>(widget));
}

void QStyle_DrawControl(void* ptr, long long element, void* option, void* painter, void* widget)
{
		static_cast<QStyle*>(ptr)->drawControl(static_cast<QStyle::ControlElement>(element), static_cast<QStyleOption*>(option), static_cast<QPainter*>(painter), static_cast<QWidget*>(widget));
}

void QStyle_DrawItemPixmap(void* ptr, void* painter, void* rectangle, int alignment, void* pixmap)
{
	static_cast<QStyle*>(ptr)->drawItemPixmap(static_cast<QPainter*>(painter), *static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap));
}

void QStyle_DrawItemPixmapDefault(void* ptr, void* painter, void* rectangle, int alignment, void* pixmap)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::drawItemPixmap(static_cast<QPainter*>(painter), *static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap));
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::drawItemPixmap(static_cast<QPainter*>(painter), *static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap));
	} else {
		static_cast<QStyle*>(ptr)->QStyle::drawItemPixmap(static_cast<QPainter*>(painter), *static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap));
	}
}

void QStyle_DrawItemText(void* ptr, void* painter, void* rectangle, int alignment, void* palette, char enabled, struct QtWidgets_PackedString text, long long textRole)
{
	static_cast<QStyle*>(ptr)->drawItemText(static_cast<QPainter*>(painter), *static_cast<QRect*>(rectangle), alignment, *static_cast<QPalette*>(palette), enabled != 0, QString::fromUtf8(text.data, text.len), static_cast<QPalette::ColorRole>(textRole));
}

void QStyle_DrawItemTextDefault(void* ptr, void* painter, void* rectangle, int alignment, void* palette, char enabled, struct QtWidgets_PackedString text, long long textRole)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::drawItemText(static_cast<QPainter*>(painter), *static_cast<QRect*>(rectangle), alignment, *static_cast<QPalette*>(palette), enabled != 0, QString::fromUtf8(text.data, text.len), static_cast<QPalette::ColorRole>(textRole));
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::drawItemText(static_cast<QPainter*>(painter), *static_cast<QRect*>(rectangle), alignment, *static_cast<QPalette*>(palette), enabled != 0, QString::fromUtf8(text.data, text.len), static_cast<QPalette::ColorRole>(textRole));
	} else {
		static_cast<QStyle*>(ptr)->QStyle::drawItemText(static_cast<QPainter*>(painter), *static_cast<QRect*>(rectangle), alignment, *static_cast<QPalette*>(palette), enabled != 0, QString::fromUtf8(text.data, text.len), static_cast<QPalette::ColorRole>(textRole));
	}
}

void QStyle_DrawPrimitive(void* ptr, long long element, void* option, void* painter, void* widget)
{
		static_cast<QStyle*>(ptr)->drawPrimitive(static_cast<QStyle::PrimitiveElement>(element), static_cast<QStyleOption*>(option), static_cast<QPainter*>(painter), static_cast<QWidget*>(widget));
}

void* QStyle_GeneratedIconPixmap(void* ptr, long long iconMode, void* pixmap, void* option)
{
	return new QPixmap(static_cast<QStyle*>(ptr)->generatedIconPixmap(static_cast<QIcon::Mode>(iconMode), *static_cast<QPixmap*>(pixmap), static_cast<QStyleOption*>(option)));
}

long long QStyle_HitTestComplexControl(void* ptr, long long control, void* option, void* position, void* widget)
{
		return static_cast<QStyle*>(ptr)->hitTestComplexControl(static_cast<QStyle::ComplexControl>(control), static_cast<QStyleOptionComplex*>(option), *static_cast<QPoint*>(position), static_cast<QWidget*>(widget));
}

void* QStyle_ItemPixmapRect(void* ptr, void* rectangle, int alignment, void* pixmap)
{
	return ({ QRect tmpValue = static_cast<QStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QStyle_ItemPixmapRectDefault(void* ptr, void* rectangle, int alignment, void* pixmap)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QProxyStyle*>(ptr)->QProxyStyle::itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QCommonStyle*>(ptr)->QCommonStyle::itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRect tmpValue = static_cast<QStyle*>(ptr)->QStyle::itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QStyle_ItemTextRect(void* ptr, void* metrics, void* rectangle, int alignment, char enabled, struct QtWidgets_PackedString text)
{
	return ({ QRect tmpValue = static_cast<QStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString::fromUtf8(text.data, text.len)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QStyle_ItemTextRectDefault(void* ptr, void* metrics, void* rectangle, int alignment, char enabled, struct QtWidgets_PackedString text)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QProxyStyle*>(ptr)->QProxyStyle::itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString::fromUtf8(text.data, text.len)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QCommonStyle*>(ptr)->QCommonStyle::itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString::fromUtf8(text.data, text.len)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRect tmpValue = static_cast<QStyle*>(ptr)->QStyle::itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString::fromUtf8(text.data, text.len)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

int QStyle_LayoutSpacing(void* ptr, long long control1, long long control2, long long orientation, void* option, void* widget)
{
		return static_cast<QStyle*>(ptr)->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget));
}

int QStyle_PixelMetric(void* ptr, long long metric, void* option, void* widget)
{
		return static_cast<QStyle*>(ptr)->pixelMetric(static_cast<QStyle::PixelMetric>(metric), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget));
}

void QStyle_Polish(void* ptr, void* widget)
{
		static_cast<QStyle*>(ptr)->polish(static_cast<QWidget*>(widget));
}

void QStyle_PolishDefault(void* ptr, void* widget)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::polish(static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::polish(static_cast<QWidget*>(widget));
	} else {
		static_cast<QStyle*>(ptr)->QStyle::polish(static_cast<QWidget*>(widget));
	}
}

void QStyle_Polish2(void* ptr, void* application)
{
	static_cast<QStyle*>(ptr)->polish(static_cast<QApplication*>(application));
}

void QStyle_Polish2Default(void* ptr, void* application)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::polish(static_cast<QApplication*>(application));
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::polish(static_cast<QApplication*>(application));
	} else {
		static_cast<QStyle*>(ptr)->QStyle::polish(static_cast<QApplication*>(application));
	}
}

void QStyle_Polish3(void* ptr, void* palette)
{
	static_cast<QStyle*>(ptr)->polish(*static_cast<QPalette*>(palette));
}

void QStyle_Polish3Default(void* ptr, void* palette)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::polish(*static_cast<QPalette*>(palette));
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::polish(*static_cast<QPalette*>(palette));
	} else {
		static_cast<QStyle*>(ptr)->QStyle::polish(*static_cast<QPalette*>(palette));
	}
}

void* QStyle_Proxy(void* ptr)
{
	return const_cast<QStyle*>(static_cast<QStyle*>(ptr)->proxy());
}

void* QStyle_SizeFromContents(void* ptr, long long ty, void* option, void* contentsSize, void* widget)
{
		return ({ QSize tmpValue = static_cast<QStyle*>(ptr)->sizeFromContents(static_cast<QStyle::ContentsType>(ty), static_cast<QStyleOption*>(option), *static_cast<QSize*>(contentsSize), static_cast<QWidget*>(widget)); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QStyle_QStyle_SliderPositionFromValue(int min, int max, int logicalValue, int span, char upsideDown)
{
	return QStyle::sliderPositionFromValue(min, max, logicalValue, span, upsideDown != 0);
}

int QStyle_QStyle_SliderValueFromPosition(int min, int max, int position, int span, char upsideDown)
{
	return QStyle::sliderValueFromPosition(min, max, position, span, upsideDown != 0);
}

void* QStyle_StandardIcon(void* ptr, long long standardIcon, void* option, void* widget)
{
		return new QIcon(static_cast<QStyle*>(ptr)->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget)));
}

void* QStyle_StandardPalette(void* ptr)
{
	return new QPalette(static_cast<QStyle*>(ptr)->standardPalette());
}

void* QStyle_StandardPaletteDefault(void* ptr)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return new QPalette(static_cast<QProxyStyle*>(ptr)->QProxyStyle::standardPalette());
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		return new QPalette(static_cast<QCommonStyle*>(ptr)->QCommonStyle::standardPalette());
	} else {
		return new QPalette(static_cast<QStyle*>(ptr)->QStyle::standardPalette());
	}
}

int QStyle_StyleHint(void* ptr, long long hint, void* option, void* widget, void* returnData)
{
		return static_cast<QStyle*>(ptr)->styleHint(static_cast<QStyle::StyleHint>(hint), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget), static_cast<QStyleHintReturn*>(returnData));
}

void* QStyle_SubControlRect(void* ptr, long long control, void* option, long long subControl, void* widget)
{
		return ({ QRect tmpValue = static_cast<QStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(control), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(subControl), static_cast<QWidget*>(widget)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QStyle_SubElementRect(void* ptr, long long element, void* option, void* widget)
{
		return ({ QRect tmpValue = static_cast<QStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(element), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QStyle_Unpolish(void* ptr, void* widget)
{
		static_cast<QStyle*>(ptr)->unpolish(static_cast<QWidget*>(widget));
}

void QStyle_UnpolishDefault(void* ptr, void* widget)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::unpolish(static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::unpolish(static_cast<QWidget*>(widget));
	} else {
		static_cast<QStyle*>(ptr)->QStyle::unpolish(static_cast<QWidget*>(widget));
	}
}

void QStyle_Unpolish2(void* ptr, void* application)
{
	static_cast<QStyle*>(ptr)->unpolish(static_cast<QApplication*>(application));
}

void QStyle_Unpolish2Default(void* ptr, void* application)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::unpolish(static_cast<QApplication*>(application));
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::unpolish(static_cast<QApplication*>(application));
	} else {
		static_cast<QStyle*>(ptr)->QStyle::unpolish(static_cast<QApplication*>(application));
	}
}

long long QStyle_QStyle_VisualAlignment(long long direction, long long alignment)
{
	return QStyle::visualAlignment(static_cast<Qt::LayoutDirection>(direction), static_cast<Qt::AlignmentFlag>(alignment));
}

void* QStyle_QStyle_VisualPos(long long direction, void* boundingRectangle, void* logicalPosition)
{
	return ({ QPoint tmpValue = QStyle::visualPos(static_cast<Qt::LayoutDirection>(direction), *static_cast<QRect*>(boundingRectangle), *static_cast<QPoint*>(logicalPosition)); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QStyle_QStyle_VisualRect(long long direction, void* boundingRectangle, void* logicalRectangle)
{
	return ({ QRect tmpValue = QStyle::visualRect(static_cast<Qt::LayoutDirection>(direction), *static_cast<QRect*>(boundingRectangle), *static_cast<QRect*>(logicalRectangle)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QStyle_DestroyQStyle(void* ptr)
{
	static_cast<QStyle*>(ptr)->~QStyle();
}

void QStyle_DestroyQStyleDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QStyle_StandardPixmap(void* ptr, long long standardIcon, void* option, void* widget)
{
		return new QPixmap(static_cast<QStyle*>(ptr)->standardPixmap(static_cast<QStyle::StandardPixmap>(standardIcon), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget)));
}

void* QStyle___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QStyle___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QStyle___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QStyle___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QStyle___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QStyle___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QStyle___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void QStyle_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QStyle*>(ptr)->QStyle::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QStyle_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QStyle*>(ptr)->QStyle::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QStyle_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QStyle*>(ptr)->QStyle::customEvent(static_cast<QEvent*>(event));
	}
}

void QStyle_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::deleteLater();
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::deleteLater();
	} else {
		static_cast<QStyle*>(ptr)->QStyle::deleteLater();
	}
}

void QStyle_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QStyle*>(ptr)->QStyle::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

char QStyle_EventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProxyStyle*>(ptr)->QProxyStyle::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCommonStyle*>(ptr)->QCommonStyle::event(static_cast<QEvent*>(e));
	} else {
		return static_cast<QStyle*>(ptr)->QStyle::event(static_cast<QEvent*>(e));
	}
}

char QStyle_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QProxyStyle*>(ptr)->QProxyStyle::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QProxyStyle*>(ptr)->QProxyStyle::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QProxyStyle*>(ptr)->QProxyStyle::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QProxyStyle*>(ptr)->QProxyStyle::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QProxyStyle*>(ptr)->QProxyStyle::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QCommonStyle*>(ptr)->QCommonStyle::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCommonStyle*>(ptr)->QCommonStyle::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QCommonStyle*>(ptr)->QCommonStyle::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCommonStyle*>(ptr)->QCommonStyle::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCommonStyle*>(ptr)->QCommonStyle::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QStyle*>(ptr)->QStyle::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QStyle*>(ptr)->QStyle::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QStyle*>(ptr)->QStyle::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QStyle*>(ptr)->QStyle::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QStyle*>(ptr)->QStyle::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void* QStyle_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::metaObject());
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QStyle*>(ptr)->QStyle::metaObject());
	}
}

void QStyle_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QProxyStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QProxyStyle*>(ptr)->QProxyStyle::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCommonStyle*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommonStyle*>(ptr)->QCommonStyle::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QStyle*>(ptr)->QStyle::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

void* QStyleFactory_QStyleFactory_Create(struct QtWidgets_PackedString key)
{
	return QStyleFactory::create(QString::fromUtf8(key.data, key.len));
}

struct QtWidgets_PackedString QStyleFactory_QStyleFactory_Keys()
{
	return ({ QByteArray* t733aa8 = new QByteArray(QStyleFactory::keys().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t733aa8->prepend("WHITESPACE").constData()+10), t733aa8->size()-10, t733aa8 }; });
}

Q_DECLARE_METATYPE(QStyleHintReturn*)
void* QStyleHintReturn_NewQStyleHintReturn(int version, int ty)
{
	return new QStyleHintReturn(version, ty);
}

int QStyleHintReturn_Version(void* ptr)
{
	return static_cast<QStyleHintReturn*>(ptr)->version;
}

void QStyleHintReturn_SetVersion(void* ptr, int vin)
{
	static_cast<QStyleHintReturn*>(ptr)->version = vin;
}

int QStyleHintReturn_Type(void* ptr)
{
	return static_cast<QStyleHintReturn*>(ptr)->type;
}

void QStyleHintReturn_SetType(void* ptr, int vin)
{
	static_cast<QStyleHintReturn*>(ptr)->type = vin;
}

Q_DECLARE_METATYPE(QStyleHintReturnMask)
Q_DECLARE_METATYPE(QStyleHintReturnMask*)
void* QStyleHintReturnMask_NewQStyleHintReturnMask()
{
	return new QStyleHintReturnMask();
}

void QStyleHintReturnMask_DestroyQStyleHintReturnMask(void* ptr)
{
	static_cast<QStyleHintReturnMask*>(ptr)->~QStyleHintReturnMask();
}

void* QStyleHintReturnMask_Region(void* ptr)
{
	return new QRegion(static_cast<QStyleHintReturnMask*>(ptr)->region);
}

void QStyleHintReturnMask_SetRegion(void* ptr, void* vqr)
{
	static_cast<QStyleHintReturnMask*>(ptr)->region = *static_cast<QRegion*>(vqr);
}

Q_DECLARE_METATYPE(QStyleHintReturnVariant)
Q_DECLARE_METATYPE(QStyleHintReturnVariant*)
void* QStyleHintReturnVariant_NewQStyleHintReturnVariant()
{
	return new QStyleHintReturnVariant();
}

void QStyleHintReturnVariant_DestroyQStyleHintReturnVariant(void* ptr)
{
	static_cast<QStyleHintReturnVariant*>(ptr)->~QStyleHintReturnVariant();
}

void* QStyleHintReturnVariant_Variant(void* ptr)
{
	return new QVariant(static_cast<QStyleHintReturnVariant*>(ptr)->variant);
}

void QStyleHintReturnVariant_SetVariant(void* ptr, void* vqv)
{
	static_cast<QStyleHintReturnVariant*>(ptr)->variant = *static_cast<QVariant*>(vqv);
}

Q_DECLARE_METATYPE(QStyleOption*)
void* QStyleOption_NewQStyleOption(int version, int ty)
{
	return new QStyleOption(version, ty);
}

void* QStyleOption_NewQStyleOption2(void* other)
{
	return new QStyleOption(*static_cast<QStyleOption*>(other));
}

void QStyleOption_InitFrom(void* ptr, void* widget)
{
		static_cast<QStyleOption*>(ptr)->initFrom(static_cast<QWidget*>(widget));
}

void QStyleOption_DestroyQStyleOption(void* ptr)
{
	static_cast<QStyleOption*>(ptr)->~QStyleOption();
}

int QStyleOption_Version(void* ptr)
{
	return static_cast<QStyleOption*>(ptr)->version;
}

void QStyleOption_SetVersion(void* ptr, int vin)
{
	static_cast<QStyleOption*>(ptr)->version = vin;
}

int QStyleOption_Type(void* ptr)
{
	return static_cast<QStyleOption*>(ptr)->type;
}

void QStyleOption_SetType(void* ptr, int vin)
{
	static_cast<QStyleOption*>(ptr)->type = vin;
}

long long QStyleOption_State(void* ptr)
{
	return static_cast<QStyleOption*>(ptr)->state;
}

void QStyleOption_SetState(void* ptr, long long vqs)
{
	static_cast<QStyleOption*>(ptr)->state = static_cast<QStyle::StateFlag>(vqs);
}

long long QStyleOption_Direction(void* ptr)
{
	return static_cast<QStyleOption*>(ptr)->direction;
}

void QStyleOption_SetDirection(void* ptr, long long vqt)
{
	static_cast<QStyleOption*>(ptr)->direction = static_cast<Qt::LayoutDirection>(vqt);
}

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

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

void* QStyleOption_FontMetrics(void* ptr)
{
	return new QFontMetrics(static_cast<QStyleOption*>(ptr)->fontMetrics);
}

void QStyleOption_SetFontMetrics(void* ptr, void* vqf)
{
	static_cast<QStyleOption*>(ptr)->fontMetrics = *static_cast<QFontMetrics*>(vqf);
}

void* QStyleOption_Palette(void* ptr)
{
	return new QPalette(static_cast<QStyleOption*>(ptr)->palette);
}

void QStyleOption_SetPalette(void* ptr, void* vqp)
{
	static_cast<QStyleOption*>(ptr)->palette = *static_cast<QPalette*>(vqp);
}

void* QStyleOption_StyleObject(void* ptr)
{
	return static_cast<QStyleOption*>(ptr)->styleObject;
}

void QStyleOption_SetStyleObject(void* ptr, void* vqo)
{
		static_cast<QStyleOption*>(ptr)->styleObject = static_cast<QObject*>(vqo);
}

Q_DECLARE_METATYPE(QStyleOptionButton)
Q_DECLARE_METATYPE(QStyleOptionButton*)
void* QStyleOptionButton_NewQStyleOptionButton()
{
	return new QStyleOptionButton();
}

void* QStyleOptionButton_NewQStyleOptionButton2(void* other)
{
	return new QStyleOptionButton(*static_cast<QStyleOptionButton*>(other));
}

long long QStyleOptionButton_Features(void* ptr)
{
	return static_cast<QStyleOptionButton*>(ptr)->features;
}

void QStyleOptionButton_SetFeatures(void* ptr, long long vqs)
{
	static_cast<QStyleOptionButton*>(ptr)->features = static_cast<QStyleOptionButton::ButtonFeature>(vqs);
}

struct QtWidgets_PackedString QStyleOptionButton_Text(void* ptr)
{
	return ({ QByteArray* t3af65e = new QByteArray(static_cast<QStyleOptionButton*>(ptr)->text.toUtf8()); QtWidgets_PackedString { const_cast<char*>(t3af65e->prepend("WHITESPACE").constData()+10), t3af65e->size()-10, t3af65e }; });
}

void QStyleOptionButton_SetText(void* ptr, struct QtWidgets_PackedString vqs)
{
	static_cast<QStyleOptionButton*>(ptr)->text = QString::fromUtf8(vqs.data, vqs.len);
}

void* QStyleOptionButton_Icon(void* ptr)
{
	return new QIcon(static_cast<QStyleOptionButton*>(ptr)->icon);
}

void QStyleOptionButton_SetIcon(void* ptr, void* vqi)
{
	static_cast<QStyleOptionButton*>(ptr)->icon = *static_cast<QIcon*>(vqi);
}

void* QStyleOptionButton_IconSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStyleOptionButton*>(ptr)->iconSize; new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionButton_SetIconSize(void* ptr, void* vqs)
{
	static_cast<QStyleOptionButton*>(ptr)->iconSize = *static_cast<QSize*>(vqs);
}

Q_DECLARE_METATYPE(QStyleOptionComboBox)
Q_DECLARE_METATYPE(QStyleOptionComboBox*)
void* QStyleOptionComboBox_NewQStyleOptionComboBox()
{
	return new QStyleOptionComboBox();
}

void* QStyleOptionComboBox_NewQStyleOptionComboBox2(void* other)
{
	return new QStyleOptionComboBox(*static_cast<QStyleOptionComboBox*>(other));
}

char QStyleOptionComboBox_Editable(void* ptr)
{
	return static_cast<QStyleOptionComboBox*>(ptr)->editable;
}

void QStyleOptionComboBox_SetEditable(void* ptr, char vbo)
{
	static_cast<QStyleOptionComboBox*>(ptr)->editable = vbo != 0;
}

void* QStyleOptionComboBox_PopupRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QStyleOptionComboBox*>(ptr)->popupRect; new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionComboBox_SetPopupRect(void* ptr, void* vqr)
{
	static_cast<QStyleOptionComboBox*>(ptr)->popupRect = *static_cast<QRect*>(vqr);
}

char QStyleOptionComboBox_Frame(void* ptr)
{
	return static_cast<QStyleOptionComboBox*>(ptr)->frame;
}

void QStyleOptionComboBox_SetFrame(void* ptr, char vbo)
{
	static_cast<QStyleOptionComboBox*>(ptr)->frame = vbo != 0;
}

struct QtWidgets_PackedString QStyleOptionComboBox_CurrentText(void* ptr)
{
	return ({ QByteArray* t049c82 = new QByteArray(static_cast<QStyleOptionComboBox*>(ptr)->currentText.toUtf8()); QtWidgets_PackedString { const_cast<char*>(t049c82->prepend("WHITESPACE").constData()+10), t049c82->size()-10, t049c82 }; });
}

void QStyleOptionComboBox_SetCurrentText(void* ptr, struct QtWidgets_PackedString vqs)
{
	static_cast<QStyleOptionComboBox*>(ptr)->currentText = QString::fromUtf8(vqs.data, vqs.len);
}

void* QStyleOptionComboBox_CurrentIcon(void* ptr)
{
	return new QIcon(static_cast<QStyleOptionComboBox*>(ptr)->currentIcon);
}

void QStyleOptionComboBox_SetCurrentIcon(void* ptr, void* vqi)
{
	static_cast<QStyleOptionComboBox*>(ptr)->currentIcon = *static_cast<QIcon*>(vqi);
}

void* QStyleOptionComboBox_IconSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStyleOptionComboBox*>(ptr)->iconSize; new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionComboBox_SetIconSize(void* ptr, void* vqs)
{
	static_cast<QStyleOptionComboBox*>(ptr)->iconSize = *static_cast<QSize*>(vqs);
}

Q_DECLARE_METATYPE(QStyleOptionComplex*)
void* QStyleOptionComplex_NewQStyleOptionComplex(int version, int ty)
{
	return new QStyleOptionComplex(version, ty);
}

void* QStyleOptionComplex_NewQStyleOptionComplex2(void* other)
{
	return new QStyleOptionComplex(*static_cast<QStyleOptionComplex*>(other));
}

long long QStyleOptionComplex_SubControls(void* ptr)
{
	return static_cast<QStyleOptionComplex*>(ptr)->subControls;
}

void QStyleOptionComplex_SetSubControls(void* ptr, long long vqs)
{
	static_cast<QStyleOptionComplex*>(ptr)->subControls = static_cast<QStyle::SubControl>(vqs);
}

long long QStyleOptionComplex_ActiveSubControls(void* ptr)
{
	return static_cast<QStyleOptionComplex*>(ptr)->activeSubControls;
}

void QStyleOptionComplex_SetActiveSubControls(void* ptr, long long vqs)
{
	static_cast<QStyleOptionComplex*>(ptr)->activeSubControls = static_cast<QStyle::SubControl>(vqs);
}

Q_DECLARE_METATYPE(QStyleOptionDockWidget)
Q_DECLARE_METATYPE(QStyleOptionDockWidget*)
void* QStyleOptionDockWidget_NewQStyleOptionDockWidget()
{
	return new QStyleOptionDockWidget();
}

void* QStyleOptionDockWidget_NewQStyleOptionDockWidget2(void* other)
{
	return new QStyleOptionDockWidget(*static_cast<QStyleOptionDockWidget*>(other));
}

struct QtWidgets_PackedString QStyleOptionDockWidget_Title(void* ptr)
{
	return ({ QByteArray* t0c6191 = new QByteArray(static_cast<QStyleOptionDockWidget*>(ptr)->title.toUtf8()); QtWidgets_PackedString { const_cast<char*>(t0c6191->prepend("WHITESPACE").constData()+10), t0c6191->size()-10, t0c6191 }; });
}

void QStyleOptionDockWidget_SetTitle(void* ptr, struct QtWidgets_PackedString vqs)
{
	static_cast<QStyleOptionDockWidget*>(ptr)->title = QString::fromUtf8(vqs.data, vqs.len);
}

char QStyleOptionDockWidget_Closable(void* ptr)
{
	return static_cast<QStyleOptionDockWidget*>(ptr)->closable;
}

void QStyleOptionDockWidget_SetClosable(void* ptr, char vbo)
{
	static_cast<QStyleOptionDockWidget*>(ptr)->closable = vbo != 0;
}

char QStyleOptionDockWidget_Movable(void* ptr)
{
	return static_cast<QStyleOptionDockWidget*>(ptr)->movable;
}

void QStyleOptionDockWidget_SetMovable(void* ptr, char vbo)
{
	static_cast<QStyleOptionDockWidget*>(ptr)->movable = vbo != 0;
}

char QStyleOptionDockWidget_Floatable(void* ptr)
{
	return static_cast<QStyleOptionDockWidget*>(ptr)->floatable;
}

void QStyleOptionDockWidget_SetFloatable(void* ptr, char vbo)
{
	static_cast<QStyleOptionDockWidget*>(ptr)->floatable = vbo != 0;
}

Q_DECLARE_METATYPE(QStyleOptionFocusRect)
Q_DECLARE_METATYPE(QStyleOptionFocusRect*)
void* QStyleOptionFocusRect_NewQStyleOptionFocusRect()
{
	return new QStyleOptionFocusRect();
}

void* QStyleOptionFocusRect_NewQStyleOptionFocusRect2(void* other)
{
	return new QStyleOptionFocusRect(*static_cast<QStyleOptionFocusRect*>(other));
}

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

void QStyleOptionFocusRect_SetBackgroundColor(void* ptr, void* vqc)
{
	static_cast<QStyleOptionFocusRect*>(ptr)->backgroundColor = *static_cast<QColor*>(vqc);
}

Q_DECLARE_METATYPE(QStyleOptionFrame)
Q_DECLARE_METATYPE(QStyleOptionFrame*)
void* QStyleOptionFrame_NewQStyleOptionFrame()
{
	return new QStyleOptionFrame();
}

void* QStyleOptionFrame_NewQStyleOptionFrame2(void* other)
{
	return new QStyleOptionFrame(*static_cast<QStyleOptionFrame*>(other));
}

int QStyleOptionFrame_LineWidth(void* ptr)
{
	return static_cast<QStyleOptionFrame*>(ptr)->lineWidth;
}

void QStyleOptionFrame_SetLineWidth(void* ptr, int vin)
{
	static_cast<QStyleOptionFrame*>(ptr)->lineWidth = vin;
}

int QStyleOptionFrame_MidLineWidth(void* ptr)
{
	return static_cast<QStyleOptionFrame*>(ptr)->midLineWidth;
}

void QStyleOptionFrame_SetMidLineWidth(void* ptr, int vin)
{
	static_cast<QStyleOptionFrame*>(ptr)->midLineWidth = vin;
}

long long QStyleOptionFrame_Features(void* ptr)
{
	return static_cast<QStyleOptionFrame*>(ptr)->features;
}

void QStyleOptionFrame_SetFeatures(void* ptr, long long vqs)
{
	static_cast<QStyleOptionFrame*>(ptr)->features = static_cast<QStyleOptionFrame::FrameFeature>(vqs);
}

long long QStyleOptionFrame_FrameShape(void* ptr)
{
	return static_cast<QStyleOptionFrame*>(ptr)->frameShape;
}

void QStyleOptionFrame_SetFrameShape(void* ptr, long long vqf)
{
	static_cast<QStyleOptionFrame*>(ptr)->frameShape = static_cast<QFrame::Shape>(vqf);
}

Q_DECLARE_METATYPE(QStyleOptionGraphicsItem)
Q_DECLARE_METATYPE(QStyleOptionGraphicsItem*)
void* QStyleOptionGraphicsItem_NewQStyleOptionGraphicsItem()
{
	return new QStyleOptionGraphicsItem();
}

void* QStyleOptionGraphicsItem_NewQStyleOptionGraphicsItem2(void* other)
{
	return new QStyleOptionGraphicsItem(*static_cast<QStyleOptionGraphicsItem*>(other));
}

double QStyleOptionGraphicsItem_QStyleOptionGraphicsItem_LevelOfDetailFromTransform(void* worldTransform)
{
	return QStyleOptionGraphicsItem::levelOfDetailFromTransform(*static_cast<QTransform*>(worldTransform));
}

void* QStyleOptionGraphicsItem_ExposedRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QStyleOptionGraphicsItem*>(ptr)->exposedRect; new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionGraphicsItem_SetExposedRect(void* ptr, void* vqr)
{
	static_cast<QStyleOptionGraphicsItem*>(ptr)->exposedRect = *static_cast<QRectF*>(vqr);
}

Q_DECLARE_METATYPE(QStyleOptionGroupBox)
Q_DECLARE_METATYPE(QStyleOptionGroupBox*)
void* QStyleOptionGroupBox_NewQStyleOptionGroupBox()
{
	return new QStyleOptionGroupBox();
}

void* QStyleOptionGroupBox_NewQStyleOptionGroupBox2(void* other)
{
	return new QStyleOptionGroupBox(*static_cast<QStyleOptionGroupBox*>(other));
}

long long QStyleOptionGroupBox_Features(void* ptr)
{
	return static_cast<QStyleOptionGroupBox*>(ptr)->features;
}

void QStyleOptionGroupBox_SetFeatures(void* ptr, long long vqs)
{
	static_cast<QStyleOptionGroupBox*>(ptr)->features = static_cast<QStyleOptionFrame::FrameFeature>(vqs);
}

struct QtWidgets_PackedString QStyleOptionGroupBox_Text(void* ptr)
{
	return ({ QByteArray* t33bfde = new QByteArray(static_cast<QStyleOptionGroupBox*>(ptr)->text.toUtf8()); QtWidgets_PackedString { const_cast<char*>(t33bfde->prepend("WHITESPACE").constData()+10), t33bfde->size()-10, t33bfde }; });
}

void QStyleOptionGroupBox_SetText(void* ptr, struct QtWidgets_PackedString vqs)
{
	static_cast<QStyleOptionGroupBox*>(ptr)->text = QString::fromUtf8(vqs.data, vqs.len);
}

long long QStyleOptionGroupBox_TextAlignment(void* ptr)
{
	return static_cast<QStyleOptionGroupBox*>(ptr)->textAlignment;
}

void QStyleOptionGroupBox_SetTextAlignment(void* ptr, long long vqt)
{
	static_cast<QStyleOptionGroupBox*>(ptr)->textAlignment = static_cast<Qt::AlignmentFlag>(vqt);
}

void* QStyleOptionGroupBox_TextColor(void* ptr)
{
	return new QColor(static_cast<QStyleOptionGroupBox*>(ptr)->textColor);
}

void QStyleOptionGroupBox_SetTextColor(void* ptr, void* vqc)
{
	static_cast<QStyleOptionGroupBox*>(ptr)->textColor = *static_cast<QColor*>(vqc);
}

int QStyleOptionGroupBox_LineWidth(void* ptr)
{
	return static_cast<QStyleOptionGroupBox*>(ptr)->lineWidth;
}

void QStyleOptionGroupBox_SetLineWidth(void* ptr, int vin)
{
	static_cast<QStyleOptionGroupBox*>(ptr)->lineWidth = vin;
}

int QStyleOptionGroupBox_MidLineWidth(void* ptr)
{
	return static_cast<QStyleOptionGroupBox*>(ptr)->midLineWidth;
}

void QStyleOptionGroupBox_SetMidLineWidth(void* ptr, int vin)
{
	static_cast<QStyleOptionGroupBox*>(ptr)->midLineWidth = vin;
}

Q_DECLARE_METATYPE(QStyleOptionHeader)
Q_DECLARE_METATYPE(QStyleOptionHeader*)
void* QStyleOptionHeader_NewQStyleOptionHeader()
{
	return new QStyleOptionHeader();
}

void* QStyleOptionHeader_NewQStyleOptionHeader2(void* other)
{
	return new QStyleOptionHeader(*static_cast<QStyleOptionHeader*>(other));
}

int QStyleOptionHeader_Section(void* ptr)
{
	return static_cast<QStyleOptionHeader*>(ptr)->section;
}

void QStyleOptionHeader_SetSection(void* ptr, int vin)
{
	static_cast<QStyleOptionHeader*>(ptr)->section = vin;
}

struct QtWidgets_PackedString QStyleOptionHeader_Text(void* ptr)
{
	return ({ QByteArray* t8df14e = new QByteArray(static_cast<QStyleOptionHeader*>(ptr)->text.toUtf8()); QtWidgets_PackedString { const_cast<char*>(t8df14e->prepend("WHITESPACE").constData()+10), t8df14e->size()-10, t8df14e }; });
}

void QStyleOptionHeader_SetText(void* ptr, struct QtWidgets_PackedString vqs)
{
	static_cast<QStyleOptionHeader*>(ptr)->text = QString::fromUtf8(vqs.data, vqs.len);
}

long long QStyleOptionHeader_TextAlignment(void* ptr)
{
	return static_cast<QStyleOptionHeader*>(ptr)->textAlignment;
}

void QStyleOptionHeader_SetTextAlignment(void* ptr, long long vqt)
{
	static_cast<QStyleOptionHeader*>(ptr)->textAlignment = static_cast<Qt::AlignmentFlag>(vqt);
}

void* QStyleOptionHeader_Icon(void* ptr)
{
	return new QIcon(static_cast<QStyleOptionHeader*>(ptr)->icon);
}

void QStyleOptionHeader_SetIcon(void* ptr, void* vqi)
{
	static_cast<QStyleOptionHeader*>(ptr)->icon = *static_cast<QIcon*>(vqi);
}

long long QStyleOptionHeader_IconAlignment(void* ptr)
{
	return static_cast<QStyleOptionHeader*>(ptr)->iconAlignment;
}

void QStyleOptionHeader_SetIconAlignment(void* ptr, long long vqt)
{
	static_cast<QStyleOptionHeader*>(ptr)->iconAlignment = static_cast<Qt::AlignmentFlag>(vqt);
}

long long QStyleOptionHeader_Position(void* ptr)
{
	return static_cast<QStyleOptionHeader*>(ptr)->position;
}

void QStyleOptionHeader_SetPosition(void* ptr, long long vqs)
{
	static_cast<QStyleOptionHeader*>(ptr)->position = static_cast<QStyleOptionHeader::SectionPosition>(vqs);
}

long long QStyleOptionHeader_SelectedPosition(void* ptr)
{
	return static_cast<QStyleOptionHeader*>(ptr)->selectedPosition;
}

void QStyleOptionHeader_SetSelectedPosition(void* ptr, long long vqs)
{
	static_cast<QStyleOptionHeader*>(ptr)->selectedPosition = static_cast<QStyleOptionHeader::SelectedPosition>(vqs);
}

long long QStyleOptionHeader_SortIndicator(void* ptr)
{
	return static_cast<QStyleOptionHeader*>(ptr)->sortIndicator;
}

void QStyleOptionHeader_SetSortIndicator(void* ptr, long long vqs)
{
	static_cast<QStyleOptionHeader*>(ptr)->sortIndicator = static_cast<QStyleOptionHeader::SortIndicator>(vqs);
}

long long QStyleOptionHeader_Orientation(void* ptr)
{
	return static_cast<QStyleOptionHeader*>(ptr)->orientation;
}

void QStyleOptionHeader_SetOrientation(void* ptr, long long vqt)
{
	static_cast<QStyleOptionHeader*>(ptr)->orientation = static_cast<Qt::Orientation>(vqt);
}

Q_DECLARE_METATYPE(QStyleOptionMenuItem)
Q_DECLARE_METATYPE(QStyleOptionMenuItem*)
void* QStyleOptionMenuItem_NewQStyleOptionMenuItem()
{
	return new QStyleOptionMenuItem();
}

void* QStyleOptionMenuItem_NewQStyleOptionMenuItem2(void* other)
{
	return new QStyleOptionMenuItem(*static_cast<QStyleOptionMenuItem*>(other));
}

long long QStyleOptionMenuItem_MenuItemType(void* ptr)
{
	return static_cast<QStyleOptionMenuItem*>(ptr)->menuItemType;
}

void QStyleOptionMenuItem_SetMenuItemType(void* ptr, long long vqs)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->menuItemType = static_cast<QStyleOptionMenuItem::MenuItemType>(vqs);
}

long long QStyleOptionMenuItem_CheckType(void* ptr)
{
	return static_cast<QStyleOptionMenuItem*>(ptr)->checkType;
}

void QStyleOptionMenuItem_SetCheckType(void* ptr, long long vqs)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->checkType = static_cast<QStyleOptionMenuItem::CheckType>(vqs);
}

char QStyleOptionMenuItem_Checked(void* ptr)
{
	return static_cast<QStyleOptionMenuItem*>(ptr)->checked;
}

void QStyleOptionMenuItem_SetChecked(void* ptr, char vbo)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->checked = vbo != 0;
}

char QStyleOptionMenuItem_MenuHasCheckableItems(void* ptr)
{
	return static_cast<QStyleOptionMenuItem*>(ptr)->menuHasCheckableItems;
}

void QStyleOptionMenuItem_SetMenuHasCheckableItems(void* ptr, char vbo)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->menuHasCheckableItems = vbo != 0;
}

void* QStyleOptionMenuItem_MenuRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QStyleOptionMenuItem*>(ptr)->menuRect; new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionMenuItem_SetMenuRect(void* ptr, void* vqr)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->menuRect = *static_cast<QRect*>(vqr);
}

struct QtWidgets_PackedString QStyleOptionMenuItem_Text(void* ptr)
{
	return ({ QByteArray* t61111c = new QByteArray(static_cast<QStyleOptionMenuItem*>(ptr)->text.toUtf8()); QtWidgets_PackedString { const_cast<char*>(t61111c->prepend("WHITESPACE").constData()+10), t61111c->size()-10, t61111c }; });
}

void QStyleOptionMenuItem_SetText(void* ptr, struct QtWidgets_PackedString vqs)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->text = QString::fromUtf8(vqs.data, vqs.len);
}

void* QStyleOptionMenuItem_Icon(void* ptr)
{
	return new QIcon(static_cast<QStyleOptionMenuItem*>(ptr)->icon);
}

void QStyleOptionMenuItem_SetIcon(void* ptr, void* vqi)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->icon = *static_cast<QIcon*>(vqi);
}

int QStyleOptionMenuItem_MaxIconWidth(void* ptr)
{
	return static_cast<QStyleOptionMenuItem*>(ptr)->maxIconWidth;
}

void QStyleOptionMenuItem_SetMaxIconWidth(void* ptr, int vin)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->maxIconWidth = vin;
}

int QStyleOptionMenuItem_TabWidth(void* ptr)
{
	return static_cast<QStyleOptionMenuItem*>(ptr)->tabWidth;
}

void QStyleOptionMenuItem_SetTabWidth(void* ptr, int vin)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->tabWidth = vin;
}

void* QStyleOptionMenuItem_Font(void* ptr)
{
	return new QFont(static_cast<QStyleOptionMenuItem*>(ptr)->font);
}

void QStyleOptionMenuItem_SetFont(void* ptr, void* vqf)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->font = *static_cast<QFont*>(vqf);
}

Q_DECLARE_METATYPE(QStyleOptionProgressBar)
Q_DECLARE_METATYPE(QStyleOptionProgressBar*)
void* QStyleOptionProgressBar_NewQStyleOptionProgressBar()
{
	return new QStyleOptionProgressBar();
}

void* QStyleOptionProgressBar_NewQStyleOptionProgressBar2(void* other)
{
	return new QStyleOptionProgressBar(*static_cast<QStyleOptionProgressBar*>(other));
}

int QStyleOptionProgressBar_Minimum(void* ptr)
{
	return static_cast<QStyleOptionProgressBar*>(ptr)->minimum;
}

void QStyleOptionProgressBar_SetMinimum(void* ptr, int vin)
{
	static_cast<QStyleOptionProgressBar*>(ptr)->minimum = vin;
}

int QStyleOptionProgressBar_Maximum(void* ptr)
{
	return static_cast<QStyleOptionProgressBar*>(ptr)->maximum;
}

void QStyleOptionProgressBar_SetMaximum(void* ptr, int vin)
{
	static_cast<QStyleOptionProgressBar*>(ptr)->maximum = vin;
}

int QStyleOptionProgressBar_Progress(void* ptr)
{
	return static_cast<QStyleOptionProgressBar*>(ptr)->progress;
}

void QStyleOptionProgressBar_SetProgress(void* ptr, int vin)
{
	static_cast<QStyleOptionProgressBar*>(ptr)->progress = vin;
}

struct QtWidgets_PackedString QStyleOptionProgressBar_Text(void* ptr)
{
	return ({ QByteArray* tfa5615 = new QByteArray(static_cast<QStyleOptionProgressBar*>(ptr)->text.toUtf8()); QtWidgets_PackedString { const_cast<char*>(tfa5615->prepend("WHITESPACE").constData()+10), tfa5615->size()-10, tfa5615 }; });
}

void QStyleOptionProgressBar_SetText(void* ptr, struct QtWidgets_PackedString vqs)
{
	static_cast<QStyleOptionProgressBar*>(ptr)->text = QString::fromUtf8(vqs.data, vqs.len);
}

long long QStyleOptionProgressBar_TextAlignment(void* ptr)
{
	return static_cast<QStyleOptionProgressBar*>(ptr)->textAlignment;
}

void QStyleOptionProgressBar_SetTextAlignment(void* ptr, long long vqt)
{
	static_cast<QStyleOptionProgressBar*>(ptr)->textAlignment = static_cast<Qt::AlignmentFlag>(vqt);
}

char QStyleOptionProgressBar_TextVisible(void* ptr)
{
	return static_cast<QStyleOptionProgressBar*>(ptr)->textVisible;
}

void QStyleOptionProgressBar_SetTextVisible(void* ptr, char vbo)
{
	static_cast<QStyleOptionProgressBar*>(ptr)->textVisible = vbo != 0;
}

char QStyleOptionProgressBar_InvertedAppearance(void* ptr)
{
	return static_cast<QStyleOptionProgressBar*>(ptr)->invertedAppearance;
}

void QStyleOptionProgressBar_SetInvertedAppearance(void* ptr, char vbo)
{
	static_cast<QStyleOptionProgressBar*>(ptr)->invertedAppearance = vbo != 0;
}

char QStyleOptionProgressBar_BottomToTop(void* ptr)
{
	return static_cast<QStyleOptionProgressBar*>(ptr)->bottomToTop;
}

void QStyleOptionProgressBar_SetBottomToTop(void* ptr, char vbo)
{
	static_cast<QStyleOptionProgressBar*>(ptr)->bottomToTop = vbo != 0;
}

Q_DECLARE_METATYPE(QStyleOptionRubberBand)
Q_DECLARE_METATYPE(QStyleOptionRubberBand*)
void* QStyleOptionRubberBand_NewQStyleOptionRubberBand()
{
	return new QStyleOptionRubberBand();
}

void* QStyleOptionRubberBand_NewQStyleOptionRubberBand2(void* other)
{
	return new QStyleOptionRubberBand(*static_cast<QStyleOptionRubberBand*>(other));
}

long long QStyleOptionRubberBand_Shape(void* ptr)
{
	return static_cast<QStyleOptionRubberBand*>(ptr)->shape;
}

void QStyleOptionRubberBand_SetShape(void* ptr, long long vqr)
{
	static_cast<QStyleOptionRubberBand*>(ptr)->shape = static_cast<QRubberBand::Shape>(vqr);
}

char QStyleOptionRubberBand_Opaque(void* ptr)
{
	return static_cast<QStyleOptionRubberBand*>(ptr)->opaque;
}

void QStyleOptionRubberBand_SetOpaque(void* ptr, char vbo)
{
	static_cast<QStyleOptionRubberBand*>(ptr)->opaque = vbo != 0;
}

Q_DECLARE_METATYPE(QStyleOptionSizeGrip)
Q_DECLARE_METATYPE(QStyleOptionSizeGrip*)
void* QStyleOptionSizeGrip_NewQStyleOptionSizeGrip()
{
	return new QStyleOptionSizeGrip();
}

void* QStyleOptionSizeGrip_NewQStyleOptionSizeGrip2(void* other)
{
	return new QStyleOptionSizeGrip(*static_cast<QStyleOptionSizeGrip*>(other));
}

long long QStyleOptionSizeGrip_Corner(void* ptr)
{
	return static_cast<QStyleOptionSizeGrip*>(ptr)->corner;
}

void QStyleOptionSizeGrip_SetCorner(void* ptr, long long vqt)
{
	static_cast<QStyleOptionSizeGrip*>(ptr)->corner = static_cast<Qt::Corner>(vqt);
}

Q_DECLARE_METATYPE(QStyleOptionSlider)
Q_DECLARE_METATYPE(QStyleOptionSlider*)
void* QStyleOptionSlider_NewQStyleOptionSlider()
{
	return new QStyleOptionSlider();
}

void* QStyleOptionSlider_NewQStyleOptionSlider2(void* other)
{
	return new QStyleOptionSlider(*static_cast<QStyleOptionSlider*>(other));
}

long long QStyleOptionSlider_Orientation(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->orientation;
}

void QStyleOptionSlider_SetOrientation(void* ptr, long long vqt)
{
	static_cast<QStyleOptionSlider*>(ptr)->orientation = static_cast<Qt::Orientation>(vqt);
}

int QStyleOptionSlider_Minimum(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->minimum;
}

void QStyleOptionSlider_SetMinimum(void* ptr, int vin)
{
	static_cast<QStyleOptionSlider*>(ptr)->minimum = vin;
}

int QStyleOptionSlider_Maximum(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->maximum;
}

void QStyleOptionSlider_SetMaximum(void* ptr, int vin)
{
	static_cast<QStyleOptionSlider*>(ptr)->maximum = vin;
}

long long QStyleOptionSlider_TickPosition(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->tickPosition;
}

void QStyleOptionSlider_SetTickPosition(void* ptr, long long vqs)
{
	static_cast<QStyleOptionSlider*>(ptr)->tickPosition = static_cast<QSlider::TickPosition>(vqs);
}

int QStyleOptionSlider_TickInterval(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->tickInterval;
}

void QStyleOptionSlider_SetTickInterval(void* ptr, int vin)
{
	static_cast<QStyleOptionSlider*>(ptr)->tickInterval = vin;
}

char QStyleOptionSlider_UpsideDown(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->upsideDown;
}

void QStyleOptionSlider_SetUpsideDown(void* ptr, char vbo)
{
	static_cast<QStyleOptionSlider*>(ptr)->upsideDown = vbo != 0;
}

int QStyleOptionSlider_SliderPosition(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->sliderPosition;
}

void QStyleOptionSlider_SetSliderPosition(void* ptr, int vin)
{
	static_cast<QStyleOptionSlider*>(ptr)->sliderPosition = vin;
}

int QStyleOptionSlider_SliderValue(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->sliderValue;
}

void QStyleOptionSlider_SetSliderValue(void* ptr, int vin)
{
	static_cast<QStyleOptionSlider*>(ptr)->sliderValue = vin;
}

int QStyleOptionSlider_SingleStep(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->singleStep;
}

void QStyleOptionSlider_SetSingleStep(void* ptr, int vin)
{
	static_cast<QStyleOptionSlider*>(ptr)->singleStep = vin;
}

int QStyleOptionSlider_PageStep(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->pageStep;
}

void QStyleOptionSlider_SetPageStep(void* ptr, int vin)
{
	static_cast<QStyleOptionSlider*>(ptr)->pageStep = vin;
}

double QStyleOptionSlider_NotchTarget(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->notchTarget;
}

void QStyleOptionSlider_SetNotchTarget(void* ptr, double vqr)
{
	static_cast<QStyleOptionSlider*>(ptr)->notchTarget = vqr;
}

char QStyleOptionSlider_DialWrapping(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->dialWrapping;
}

void QStyleOptionSlider_SetDialWrapping(void* ptr, char vbo)
{
	static_cast<QStyleOptionSlider*>(ptr)->dialWrapping = vbo != 0;
}

Q_DECLARE_METATYPE(QStyleOptionSpinBox)
Q_DECLARE_METATYPE(QStyleOptionSpinBox*)
void* QStyleOptionSpinBox_NewQStyleOptionSpinBox()
{
	return new QStyleOptionSpinBox();
}

void* QStyleOptionSpinBox_NewQStyleOptionSpinBox2(void* other)
{
	return new QStyleOptionSpinBox(*static_cast<QStyleOptionSpinBox*>(other));
}

long long QStyleOptionSpinBox_ButtonSymbols(void* ptr)
{
	return static_cast<QStyleOptionSpinBox*>(ptr)->buttonSymbols;
}

void QStyleOptionSpinBox_SetButtonSymbols(void* ptr, long long vqa)
{
	static_cast<QStyleOptionSpinBox*>(ptr)->buttonSymbols = static_cast<QAbstractSpinBox::ButtonSymbols>(vqa);
}

long long QStyleOptionSpinBox_StepEnabled(void* ptr)
{
	return static_cast<QStyleOptionSpinBox*>(ptr)->stepEnabled;
}

void QStyleOptionSpinBox_SetStepEnabled(void* ptr, long long vqa)
{
	static_cast<QStyleOptionSpinBox*>(ptr)->stepEnabled = static_cast<QAbstractSpinBox::StepEnabledFlag>(vqa);
}

char QStyleOptionSpinBox_Frame(void* ptr)
{
	return static_cast<QStyleOptionSpinBox*>(ptr)->frame;
}

void QStyleOptionSpinBox_SetFrame(void* ptr, char vbo)
{
	static_cast<QStyleOptionSpinBox*>(ptr)->frame = vbo != 0;
}

Q_DECLARE_METATYPE(QStyleOptionTab)
Q_DECLARE_METATYPE(QStyleOptionTab*)
void* QStyleOptionTab_NewQStyleOptionTab()
{
	return new QStyleOptionTab();
}

void* QStyleOptionTab_NewQStyleOptionTab2(void* other)
{
	return new QStyleOptionTab(*static_cast<QStyleOptionTab*>(other));
}

long long QStyleOptionTab_Shape(void* ptr)
{
	return static_cast<QStyleOptionTab*>(ptr)->shape;
}

void QStyleOptionTab_SetShape(void* ptr, long long vqt)
{
	static_cast<QStyleOptionTab*>(ptr)->shape = static_cast<QTabBar::Shape>(vqt);
}

struct QtWidgets_PackedString QStyleOptionTab_Text(void* ptr)
{
	return ({ QByteArray* t12932f = new QByteArray(static_cast<QStyleOptionTab*>(ptr)->text.toUtf8()); QtWidgets_PackedString { const_cast<char*>(t12932f->prepend("WHITESPACE").constData()+10), t12932f->size()-10, t12932f }; });
}

void QStyleOptionTab_SetText(void* ptr, struct QtWidgets_PackedString vqs)
{
	static_cast<QStyleOptionTab*>(ptr)->text = QString::fromUtf8(vqs.data, vqs.len);
}

void* QStyleOptionTab_Icon(void* ptr)
{
	return new QIcon(static_cast<QStyleOptionTab*>(ptr)->icon);
}

void QStyleOptionTab_SetIcon(void* ptr, void* vqi)
{
	static_cast<QStyleOptionTab*>(ptr)->icon = *static_cast<QIcon*>(vqi);
}

int QStyleOptionTab_Row(void* ptr)
{
	return static_cast<QStyleOptionTab*>(ptr)->row;
}

void QStyleOptionTab_SetRow(void* ptr, int vin)
{
	static_cast<QStyleOptionTab*>(ptr)->row = vin;
}

long long QStyleOptionTab_Position(void* ptr)
{
	return static_cast<QStyleOptionTab*>(ptr)->position;
}

void QStyleOptionTab_SetPosition(void* ptr, long long vqs)
{
	static_cast<QStyleOptionTab*>(ptr)->position = static_cast<QStyleOptionTab::TabPosition>(vqs);
}

long long QStyleOptionTab_SelectedPosition(void* ptr)
{
	return static_cast<QStyleOptionTab*>(ptr)->selectedPosition;
}

void QStyleOptionTab_SetSelectedPosition(void* ptr, long long vqs)
{
	static_cast<QStyleOptionTab*>(ptr)->selectedPosition = static_cast<QStyleOptionTab::SelectedPosition>(vqs);
}

long long QStyleOptionTab_CornerWidgets(void* ptr)
{
	return static_cast<QStyleOptionTab*>(ptr)->cornerWidgets;
}

void QStyleOptionTab_SetCornerWidgets(void* ptr, long long vqs)
{
	static_cast<QStyleOptionTab*>(ptr)->cornerWidgets = static_cast<QStyleOptionTab::CornerWidget>(vqs);
}

void* QStyleOptionTab_IconSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStyleOptionTab*>(ptr)->iconSize; new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionTab_SetIconSize(void* ptr, void* vqs)
{
	static_cast<QStyleOptionTab*>(ptr)->iconSize = *static_cast<QSize*>(vqs);
}

char QStyleOptionTab_DocumentMode(void* ptr)
{
	return static_cast<QStyleOptionTab*>(ptr)->documentMode;
}

void QStyleOptionTab_SetDocumentMode(void* ptr, char vbo)
{
	static_cast<QStyleOptionTab*>(ptr)->documentMode = vbo != 0;
}

void* QStyleOptionTab_LeftButtonSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStyleOptionTab*>(ptr)->leftButtonSize; new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionTab_SetLeftButtonSize(void* ptr, void* vqs)
{
	static_cast<QStyleOptionTab*>(ptr)->leftButtonSize = *static_cast<QSize*>(vqs);
}

void* QStyleOptionTab_RightButtonSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStyleOptionTab*>(ptr)->rightButtonSize; new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionTab_SetRightButtonSize(void* ptr, void* vqs)
{
	static_cast<QStyleOptionTab*>(ptr)->rightButtonSize = *static_cast<QSize*>(vqs);
}

Q_DECLARE_METATYPE(QStyleOptionTabBarBase)
Q_DECLARE_METATYPE(QStyleOptionTabBarBase*)
void* QStyleOptionTabBarBase_NewQStyleOptionTabBarBase()
{
	return new QStyleOptionTabBarBase();
}

void* QStyleOptionTabBarBase_NewQStyleOptionTabBarBase2(void* other)
{
	return new QStyleOptionTabBarBase(*static_cast<QStyleOptionTabBarBase*>(other));
}

long long QStyleOptionTabBarBase_Shape(void* ptr)
{
	return static_cast<QStyleOptionTabBarBase*>(ptr)->shape;
}

void QStyleOptionTabBarBase_SetShape(void* ptr, long long vqt)
{
	static_cast<QStyleOptionTabBarBase*>(ptr)->shape = static_cast<QTabBar::Shape>(vqt);
}

void* QStyleOptionTabBarBase_TabBarRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QStyleOptionTabBarBase*>(ptr)->tabBarRect; new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionTabBarBase_SetTabBarRect(void* ptr, void* vqr)
{
	static_cast<QStyleOptionTabBarBase*>(ptr)->tabBarRect = *static_cast<QRect*>(vqr);
}

void* QStyleOptionTabBarBase_SelectedTabRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QStyleOptionTabBarBase*>(ptr)->selectedTabRect; new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionTabBarBase_SetSelectedTabRect(void* ptr, void* vqr)
{
	static_cast<QStyleOptionTabBarBase*>(ptr)->selectedTabRect = *static_cast<QRect*>(vqr);
}

char QStyleOptionTabBarBase_DocumentMode(void* ptr)
{
	return static_cast<QStyleOptionTabBarBase*>(ptr)->documentMode;
}

void QStyleOptionTabBarBase_SetDocumentMode(void* ptr, char vbo)
{
	static_cast<QStyleOptionTabBarBase*>(ptr)->documentMode = vbo != 0;
}

Q_DECLARE_METATYPE(QStyleOptionTabWidgetFrame)
Q_DECLARE_METATYPE(QStyleOptionTabWidgetFrame*)
void* QStyleOptionTabWidgetFrame_NewQStyleOptionTabWidgetFrame()
{
	return new QStyleOptionTabWidgetFrame();
}

void* QStyleOptionTabWidgetFrame_NewQStyleOptionTabWidgetFrame2(void* other)
{
	return new QStyleOptionTabWidgetFrame(*static_cast<QStyleOptionTabWidgetFrame*>(other));
}

int QStyleOptionTabWidgetFrame_LineWidth(void* ptr)
{
	return static_cast<QStyleOptionTabWidgetFrame*>(ptr)->lineWidth;
}

void QStyleOptionTabWidgetFrame_SetLineWidth(void* ptr, int vin)
{
	static_cast<QStyleOptionTabWidgetFrame*>(ptr)->lineWidth = vin;
}

int QStyleOptionTabWidgetFrame_MidLineWidth(void* ptr)
{
	return static_cast<QStyleOptionTabWidgetFrame*>(ptr)->midLineWidth;
}

void QStyleOptionTabWidgetFrame_SetMidLineWidth(void* ptr, int vin)
{
	static_cast<QStyleOptionTabWidgetFrame*>(ptr)->midLineWidth = vin;
}

long long QStyleOptionTabWidgetFrame_Shape(void* ptr)
{
	return static_cast<QStyleOptionTabWidgetFrame*>(ptr)->shape;
}

void QStyleOptionTabWidgetFrame_SetShape(void* ptr, long long vqt)
{
	static_cast<QStyleOptionTabWidgetFrame*>(ptr)->shape = static_cast<QTabBar::Shape>(vqt);
}

void* QStyleOptionTabWidgetFrame_TabBarSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStyleOptionTabWidgetFrame*>(ptr)->tabBarSize; new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionTabWidgetFrame_SetTabBarSize(void* ptr, void* vqs)
{
	static_cast<QStyleOptionTabWidgetFrame*>(ptr)->tabBarSize = *static_cast<QSize*>(vqs);
}

void* QStyleOptionTabWidgetFrame_RightCornerWidgetSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStyleOptionTabWidgetFrame*>(ptr)->rightCornerWidgetSize; new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionTabWidgetFrame_SetRightCornerWidgetSize(void* ptr, void* vqs)
{
	static_cast<QStyleOptionTabWidgetFrame*>(ptr)->rightCornerWidgetSize = *static_cast<QSize*>(vqs);
}

void* QStyleOptionTabWidgetFrame_LeftCornerWidgetSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStyleOptionTabWidgetFrame*>(ptr)->leftCornerWidgetSize; new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionTabWidgetFrame_SetLeftCornerWidgetSize(void* ptr, void* vqs)
{
	static_cast<QStyleOptionTabWidgetFrame*>(ptr)->leftCornerWidgetSize = *static_cast<QSize*>(vqs);
}

void* QStyleOptionTabWidgetFrame_TabBarRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QStyleOptionTabWidgetFrame*>(ptr)->tabBarRect; new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionTabWidgetFrame_SetTabBarRect(void* ptr, void* vqr)
{
	static_cast<QStyleOptionTabWidgetFrame*>(ptr)->tabBarRect = *static_cast<QRect*>(vqr);
}

void* QStyleOptionTabWidgetFrame_SelectedTabRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QStyleOptionTabWidgetFrame*>(ptr)->selectedTabRect; new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionTabWidgetFrame_SetSelectedTabRect(void* ptr, void* vqr)
{
	static_cast<QStyleOptionTabWidgetFrame*>(ptr)->selectedTabRect = *static_cast<QRect*>(vqr);
}

Q_DECLARE_METATYPE(QStyleOptionTitleBar)
Q_DECLARE_METATYPE(QStyleOptionTitleBar*)
void* QStyleOptionTitleBar_NewQStyleOptionTitleBar()
{
	return new QStyleOptionTitleBar();
}

void* QStyleOptionTitleBar_NewQStyleOptionTitleBar2(void* other)
{
	return new QStyleOptionTitleBar(*static_cast<QStyleOptionTitleBar*>(other));
}

struct QtWidgets_PackedString QStyleOptionTitleBar_Text(void* ptr)
{
	return ({ QByteArray* tfebd0b = new QByteArray(static_cast<QStyleOptionTitleBar*>(ptr)->text.toUtf8()); QtWidgets_PackedString { const_cast<char*>(tfebd0b->prepend("WHITESPACE").constData()+10), tfebd0b->size()-10, tfebd0b }; });
}

void QStyleOptionTitleBar_SetText(void* ptr, struct QtWidgets_PackedString vqs)
{
	static_cast<QStyleOptionTitleBar*>(ptr)->text = QString::fromUtf8(vqs.data, vqs.len);
}

void* QStyleOptionTitleBar_Icon(void* ptr)
{
	return new QIcon(static_cast<QStyleOptionTitleBar*>(ptr)->icon);
}

void QStyleOptionTitleBar_SetIcon(void* ptr, void* vqi)
{
	static_cast<QStyleOptionTitleBar*>(ptr)->icon = *static_cast<QIcon*>(vqi);
}

int QStyleOptionTitleBar_TitleBarState(void* ptr)
{
	return static_cast<QStyleOptionTitleBar*>(ptr)->titleBarState;
}

void QStyleOptionTitleBar_SetTitleBarState(void* ptr, int vin)
{
	static_cast<QStyleOptionTitleBar*>(ptr)->titleBarState = vin;
}

long long QStyleOptionTitleBar_TitleBarFlags(void* ptr)
{
	return static_cast<QStyleOptionTitleBar*>(ptr)->titleBarFlags;
}

void QStyleOptionTitleBar_SetTitleBarFlags(void* ptr, long long vqt)
{
	static_cast<QStyleOptionTitleBar*>(ptr)->titleBarFlags = static_cast<Qt::WindowType>(vqt);
}

Q_DECLARE_METATYPE(QStyleOptionToolBar)
Q_DECLARE_METATYPE(QStyleOptionToolBar*)
void* QStyleOptionToolBar_NewQStyleOptionToolBar()
{
	return new QStyleOptionToolBar();
}

void* QStyleOptionToolBar_NewQStyleOptionToolBar2(void* other)
{
	return new QStyleOptionToolBar(*static_cast<QStyleOptionToolBar*>(other));
}

long long QStyleOptionToolBar_PositionOfLine(void* ptr)
{
	return static_cast<QStyleOptionToolBar*>(ptr)->positionOfLine;
}

void QStyleOptionToolBar_SetPositionOfLine(void* ptr, long long vqs)
{
	static_cast<QStyleOptionToolBar*>(ptr)->positionOfLine = static_cast<QStyleOptionToolBar::ToolBarPosition>(vqs);
}

long long QStyleOptionToolBar_PositionWithinLine(void* ptr)
{
	return static_cast<QStyleOptionToolBar*>(ptr)->positionWithinLine;
}

void QStyleOptionToolBar_SetPositionWithinLine(void* ptr, long long vqs)
{
	static_cast<QStyleOptionToolBar*>(ptr)->positionWithinLine = static_cast<QStyleOptionToolBar::ToolBarPosition>(vqs);
}

long long QStyleOptionToolBar_ToolBarArea(void* ptr)
{
	return static_cast<QStyleOptionToolBar*>(ptr)->toolBarArea;
}

void QStyleOptionToolBar_SetToolBarArea(void* ptr, long long vqt)
{
	static_cast<QStyleOptionToolBar*>(ptr)->toolBarArea = static_cast<Qt::ToolBarArea>(vqt);
}

long long QStyleOptionToolBar_Features(void* ptr)
{
	return static_cast<QStyleOptionToolBar*>(ptr)->features;
}

void QStyleOptionToolBar_SetFeatures(void* ptr, long long vqs)
{
	static_cast<QStyleOptionToolBar*>(ptr)->features = static_cast<QStyleOptionToolBar::ToolBarFeature>(vqs);
}

int QStyleOptionToolBar_LineWidth(void* ptr)
{
	return static_cast<QStyleOptionToolBar*>(ptr)->lineWidth;
}

void QStyleOptionToolBar_SetLineWidth(void* ptr, int vin)
{
	static_cast<QStyleOptionToolBar*>(ptr)->lineWidth = vin;
}

int QStyleOptionToolBar_MidLineWidth(void* ptr)
{
	return static_cast<QStyleOptionToolBar*>(ptr)->midLineWidth;
}

void QStyleOptionToolBar_SetMidLineWidth(void* ptr, int vin)
{
	static_cast<QStyleOptionToolBar*>(ptr)->midLineWidth = vin;
}

Q_DECLARE_METATYPE(QStyleOptionToolBox)
Q_DECLARE_METATYPE(QStyleOptionToolBox*)
void* QStyleOptionToolBox_NewQStyleOptionToolBox()
{
	return new QStyleOptionToolBox();
}

void* QStyleOptionToolBox_NewQStyleOptionToolBox2(void* other)
{
	return new QStyleOptionToolBox(*static_cast<QStyleOptionToolBox*>(other));
}

struct QtWidgets_PackedString QStyleOptionToolBox_Text(void* ptr)
{
	return ({ QByteArray* t86be6c = new QByteArray(static_cast<QStyleOptionToolBox*>(ptr)->text.toUtf8()); QtWidgets_PackedString { const_cast<char*>(t86be6c->prepend("WHITESPACE").constData()+10), t86be6c->size()-10, t86be6c }; });
}

void QStyleOptionToolBox_SetText(void* ptr, struct QtWidgets_PackedString vqs)
{
	static_cast<QStyleOptionToolBox*>(ptr)->text = QString::fromUtf8(vqs.data, vqs.len);
}

void* QStyleOptionToolBox_Icon(void* ptr)
{
	return new QIcon(static_cast<QStyleOptionToolBox*>(ptr)->icon);
}

void QStyleOptionToolBox_SetIcon(void* ptr, void* vqi)
{
	static_cast<QStyleOptionToolBox*>(ptr)->icon = *static_cast<QIcon*>(vqi);
}

long long QStyleOptionToolBox_SelectedPosition(void* ptr)
{
	return static_cast<QStyleOptionToolBox*>(ptr)->selectedPosition;
}

void QStyleOptionToolBox_SetSelectedPosition(void* ptr, long long vqs)
{
	static_cast<QStyleOptionToolBox*>(ptr)->selectedPosition = static_cast<QStyleOptionToolBox::SelectedPosition>(vqs);
}

Q_DECLARE_METATYPE(QStyleOptionToolButton)
Q_DECLARE_METATYPE(QStyleOptionToolButton*)
void* QStyleOptionToolButton_NewQStyleOptionToolButton()
{
	return new QStyleOptionToolButton();
}

void* QStyleOptionToolButton_NewQStyleOptionToolButton2(void* other)
{
	return new QStyleOptionToolButton(*static_cast<QStyleOptionToolButton*>(other));
}

long long QStyleOptionToolButton_Features(void* ptr)
{
	return static_cast<QStyleOptionToolButton*>(ptr)->features;
}

void QStyleOptionToolButton_SetFeatures(void* ptr, long long vqs)
{
	static_cast<QStyleOptionToolButton*>(ptr)->features = static_cast<QStyleOptionToolButton::ToolButtonFeature>(vqs);
}

void* QStyleOptionToolButton_Icon(void* ptr)
{
	return new QIcon(static_cast<QStyleOptionToolButton*>(ptr)->icon);
}

void QStyleOptionToolButton_SetIcon(void* ptr, void* vqi)
{
	static_cast<QStyleOptionToolButton*>(ptr)->icon = *static_cast<QIcon*>(vqi);
}

void* QStyleOptionToolButton_IconSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStyleOptionToolButton*>(ptr)->iconSize; new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionToolButton_SetIconSize(void* ptr, void* vqs)
{
	static_cast<QStyleOptionToolButton*>(ptr)->iconSize = *static_cast<QSize*>(vqs);
}

struct QtWidgets_PackedString QStyleOptionToolButton_Text(void* ptr)
{
	return ({ QByteArray* t245424 = new QByteArray(static_cast<QStyleOptionToolButton*>(ptr)->text.toUtf8()); QtWidgets_PackedString { const_cast<char*>(t245424->prepend("WHITESPACE").constData()+10), t245424->size()-10, t245424 }; });
}

void QStyleOptionToolButton_SetText(void* ptr, struct QtWidgets_PackedString vqs)
{
	static_cast<QStyleOptionToolButton*>(ptr)->text = QString::fromUtf8(vqs.data, vqs.len);
}

long long QStyleOptionToolButton_ArrowType(void* ptr)
{
	return static_cast<QStyleOptionToolButton*>(ptr)->arrowType;
}

void QStyleOptionToolButton_SetArrowType(void* ptr, long long vqt)
{
	static_cast<QStyleOptionToolButton*>(ptr)->arrowType = static_cast<Qt::ArrowType>(vqt);
}

long long QStyleOptionToolButton_ToolButtonStyle(void* ptr)
{
	return static_cast<QStyleOptionToolButton*>(ptr)->toolButtonStyle;
}

void QStyleOptionToolButton_SetToolButtonStyle(void* ptr, long long vqt)
{
	static_cast<QStyleOptionToolButton*>(ptr)->toolButtonStyle = static_cast<Qt::ToolButtonStyle>(vqt);
}

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

void QStyleOptionToolButton_SetPos(void* ptr, void* vqp)
{
	static_cast<QStyleOptionToolButton*>(ptr)->pos = *static_cast<QPoint*>(vqp);
}

void* QStyleOptionToolButton_Font(void* ptr)
{
	return new QFont(static_cast<QStyleOptionToolButton*>(ptr)->font);
}

void QStyleOptionToolButton_SetFont(void* ptr, void* vqf)
{
	static_cast<QStyleOptionToolButton*>(ptr)->font = *static_cast<QFont*>(vqf);
}

Q_DECLARE_METATYPE(QStyleOptionViewItem)
Q_DECLARE_METATYPE(QStyleOptionViewItem*)
void* QStyleOptionViewItem_NewQStyleOptionViewItem()
{
	return new QStyleOptionViewItem();
}

void* QStyleOptionViewItem_NewQStyleOptionViewItem2(void* other)
{
	return new QStyleOptionViewItem(*static_cast<QStyleOptionViewItem*>(other));
}

long long QStyleOptionViewItem_DisplayAlignment(void* ptr)
{
	return static_cast<QStyleOptionViewItem*>(ptr)->displayAlignment;
}

void QStyleOptionViewItem_SetDisplayAlignment(void* ptr, long long vqt)
{
	static_cast<QStyleOptionViewItem*>(ptr)->displayAlignment = static_cast<Qt::AlignmentFlag>(vqt);
}

long long QStyleOptionViewItem_DecorationAlignment(void* ptr)
{
	return static_cast<QStyleOptionViewItem*>(ptr)->decorationAlignment;
}

void QStyleOptionViewItem_SetDecorationAlignment(void* ptr, long long vqt)
{
	static_cast<QStyleOptionViewItem*>(ptr)->decorationAlignment = static_cast<Qt::AlignmentFlag>(vqt);
}

long long QStyleOptionViewItem_TextElideMode(void* ptr)
{
	return static_cast<QStyleOptionViewItem*>(ptr)->textElideMode;
}

void QStyleOptionViewItem_SetTextElideMode(void* ptr, long long vqt)
{
	static_cast<QStyleOptionViewItem*>(ptr)->textElideMode = static_cast<Qt::TextElideMode>(vqt);
}

long long QStyleOptionViewItem_DecorationPosition(void* ptr)
{
	return static_cast<QStyleOptionViewItem*>(ptr)->decorationPosition;
}

void QStyleOptionViewItem_SetDecorationPosition(void* ptr, long long vqs)
{
	static_cast<QStyleOptionViewItem*>(ptr)->decorationPosition = static_cast<QStyleOptionViewItem::Position>(vqs);
}

void* QStyleOptionViewItem_DecorationSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStyleOptionViewItem*>(ptr)->decorationSize; new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStyleOptionViewItem_SetDecorationSize(void* ptr, void* vqs)
{
	static_cast<QStyleOptionViewItem*>(ptr)->decorationSize = *static_cast<QSize*>(vqs);
}

void* QStyleOptionViewItem_Font(void* ptr)
{
	return new QFont(static_cast<QStyleOptionViewItem*>(ptr)->font);
}

void QStyleOptionViewItem_SetFont(void* ptr, void* vqf)
{
	static_cast<QStyleOptionViewItem*>(ptr)->font = *static_cast<QFont*>(vqf);
}

char QStyleOptionViewItem_ShowDecorationSelected(void* ptr)
{
	return static_cast<QStyleOptionViewItem*>(ptr)->showDecorationSelected;
}

void QStyleOptionViewItem_SetShowDecorationSelected(void* ptr, char vbo)
{
	static_cast<QStyleOptionViewItem*>(ptr)->showDecorationSelected = vbo != 0;
}

long long QStyleOptionViewItem_Features(void* ptr)
{
	return static_cast<QStyleOptionViewItem*>(ptr)->features;
}

void QStyleOptionViewItem_SetFeatures(void* ptr, long long vqs)
{
	static_cast<QStyleOptionViewItem*>(ptr)->features = static_cast<QStyleOptionViewItem::ViewItemFeature>(vqs);
}

void* QStyleOptionViewItem_Index(void* ptr)
{
	return new QModelIndex(static_cast<QStyleOptionViewItem*>(ptr)->index);
}

void QStyleOptionViewItem_SetIndex(void* ptr, void* vqm)
{
	static_cast<QStyleOptionViewItem*>(ptr)->index = *static_cast<QModelIndex*>(vqm);
}

long long QStyleOptionViewItem_CheckState(void* ptr)
{
	return static_cast<QStyleOptionViewItem*>(ptr)->checkState;
}

void QStyleOptionViewItem_SetCheckState(void* ptr, long long vqt)
{
	static_cast<QStyleOptionViewItem*>(ptr)->checkState = static_cast<Qt::CheckState>(vqt);
}

void* QStyleOptionViewItem_Icon(void* ptr)
{
	return new QIcon(static_cast<QStyleOptionViewItem*>(ptr)->icon);
}

void QStyleOptionViewItem_SetIcon(void* ptr, void* vqi)
{
	static_cast<QStyleOptionViewItem*>(ptr)->icon = *static_cast<QIcon*>(vqi);
}

struct QtWidgets_PackedString QStyleOptionViewItem_Text(void* ptr)
{
	return ({ QByteArray* t3c2585 = new QByteArray(static_cast<QStyleOptionViewItem*>(ptr)->text.toUtf8()); QtWidgets_PackedString { const_cast<char*>(t3c2585->prepend("WHITESPACE").constData()+10), t3c2585->size()-10, t3c2585 }; });
}

void QStyleOptionViewItem_SetText(void* ptr, struct QtWidgets_PackedString vqs)
{
	static_cast<QStyleOptionViewItem*>(ptr)->text = QString::fromUtf8(vqs.data, vqs.len);
}

long long QStyleOptionViewItem_ViewItemPosition(void* ptr)
{
	return static_cast<QStyleOptionViewItem*>(ptr)->viewItemPosition;
}

void QStyleOptionViewItem_SetViewItemPosition(void* ptr, long long vqs)
{
	static_cast<QStyleOptionViewItem*>(ptr)->viewItemPosition = static_cast<QStyleOptionViewItem::ViewItemPosition>(vqs);
}

void* QStyleOptionViewItem_BackgroundBrush(void* ptr)
{
	return new QBrush(static_cast<QStyleOptionViewItem*>(ptr)->backgroundBrush);
}

void QStyleOptionViewItem_SetBackgroundBrush(void* ptr, void* vqb)
{
	static_cast<QStyleOptionViewItem*>(ptr)->backgroundBrush = *static_cast<QBrush*>(vqb);
}

Q_DECLARE_METATYPE(QStylePainter*)
void* QStylePainter_NewQStylePainter()
{
	return new QStylePainter();
}

void* QStylePainter_NewQStylePainter2(void* widget)
{
		return new QStylePainter(static_cast<QWidget*>(widget));
}

void* QStylePainter_NewQStylePainter3(void* pd, void* widget)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(pd))) {
		return new QStylePainter(static_cast<QPaintDeviceWindow*>(pd), static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(pd))) {
		return new QStylePainter(static_cast<QPdfWriter*>(pd), static_cast<QWidget*>(widget));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(pd))) {
		return new QStylePainter(static_cast<QWidget*>(pd), static_cast<QWidget*>(widget));
	} else {
		return new QStylePainter(static_cast<QPaintDevice*>(pd), static_cast<QWidget*>(widget));
	}
}

char QStylePainter_Begin(void* ptr, void* widget)
{
		return static_cast<QStylePainter*>(ptr)->begin(static_cast<QWidget*>(widget));
}

char QStylePainter_Begin2(void* ptr, void* pd, void* widget)
{
	if (dynamic_cast<QWidget*>(static_cast<QObject*>(pd))) {
		return static_cast<QStylePainter*>(ptr)->begin(static_cast<QWidget*>(pd), static_cast<QWidget*>(widget));
	} else {
		return static_cast<QStylePainter*>(ptr)->begin(static_cast<QPaintDevice*>(pd), static_cast<QWidget*>(widget));
	}
}

void QStylePainter_DrawComplexControl(void* ptr, long long cc, void* option)
{
	static_cast<QStylePainter*>(ptr)->drawComplexControl(static_cast<QStyle::ComplexControl>(cc), *static_cast<QStyleOptionComplex*>(option));
}

void QStylePainter_DrawControl(void* ptr, long long ce, void* option)
{
	static_cast<QStylePainter*>(ptr)->drawControl(static_cast<QStyle::ControlElement>(ce), *static_cast<QStyleOption*>(option));
}

void QStylePainter_DrawItemPixmap(void* ptr, void* rect, int flags, void* pixmap)
{
	static_cast<QStylePainter*>(ptr)->drawItemPixmap(*static_cast<QRect*>(rect), flags, *static_cast<QPixmap*>(pixmap));
}

void QStylePainter_DrawItemText(void* ptr, void* rect, int flags, void* pal, char enabled, struct QtWidgets_PackedString text, long long textRole)
{
	static_cast<QStylePainter*>(ptr)->drawItemText(*static_cast<QRect*>(rect), flags, *static_cast<QPalette*>(pal), enabled != 0, QString::fromUtf8(text.data, text.len), static_cast<QPalette::ColorRole>(textRole));
}

void QStylePainter_DrawPrimitive(void* ptr, long long pe, void* option)
{
	static_cast<QStylePainter*>(ptr)->drawPrimitive(static_cast<QStyle::PrimitiveElement>(pe), *static_cast<QStyleOption*>(option));
}

void* QStylePainter_Style(void* ptr)
{
	return static_cast<QStylePainter*>(ptr)->style();
}

void* QStylePainter___drawLines_lines_atList2(void* ptr, int i)
{
	return ({ QLineF tmpValue = ({QLineF tmp = static_cast<QVector<QLineF>*>(ptr)->at(i); if (i == static_cast<QVector<QLineF>*>(ptr)->size()-1) { static_cast<QVector<QLineF>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}

void QStylePainter___drawLines_lines_setList2(void* ptr, void* i)
{
	static_cast<QVector<QLineF>*>(ptr)->append(*static_cast<QLineF*>(i));
}

void* QStylePainter___drawLines_lines_newList2(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<QLineF>();
}

void* QStylePainter___drawLines_pointPairs_atList4(void* ptr, int i)
{
	return ({ QPointF tmpValue = ({QPointF tmp = static_cast<QVector<QPointF>*>(ptr)->at(i); if (i == static_cast<QVector<QPointF>*>(ptr)->size()-1) { static_cast<QVector<QPointF>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QStylePainter___drawLines_pointPairs_setList4(void* ptr, void* i)
{
	static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}

void* QStylePainter___drawLines_pointPairs_newList4(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<QPointF>();
}

void* QStylePainter___drawLines_lines_atList6(void* ptr, int i)
{
	return ({ QLine tmpValue = ({QLine tmp = static_cast<QVector<QLine>*>(ptr)->at(i); if (i == static_cast<QVector<QLine>*>(ptr)->size()-1) { static_cast<QVector<QLine>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QLine(tmpValue.p1(), tmpValue.p2()); });
}

void QStylePainter___drawLines_lines_setList6(void* ptr, void* i)
{
	static_cast<QVector<QLine>*>(ptr)->append(*static_cast<QLine*>(i));
}

void* QStylePainter___drawLines_lines_newList6(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<QLine>();
}

void* QStylePainter___drawLines_pointPairs_atList8(void* ptr, int i)
{
	return ({ QPoint tmpValue = ({QPoint tmp = static_cast<QVector<QPoint>*>(ptr)->at(i); if (i == static_cast<QVector<QPoint>*>(ptr)->size()-1) { static_cast<QVector<QPoint>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QStylePainter___drawLines_pointPairs_setList8(void* ptr, void* i)
{
	static_cast<QVector<QPoint>*>(ptr)->append(*static_cast<QPoint*>(i));
}

void* QStylePainter___drawLines_pointPairs_newList8(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<QPoint>();
}

void* QStylePainter___drawRects_rectangles_atList2(void* ptr, int i)
{
	return ({ QRectF tmpValue = ({QRectF tmp = static_cast<QVector<QRectF>*>(ptr)->at(i); if (i == static_cast<QVector<QRectF>*>(ptr)->size()-1) { static_cast<QVector<QRectF>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QStylePainter___drawRects_rectangles_setList2(void* ptr, void* i)
{
	static_cast<QVector<QRectF>*>(ptr)->append(*static_cast<QRectF*>(i));
}

void* QStylePainter___drawRects_rectangles_newList2(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<QRectF>();
}

void* QStylePainter___drawRects_rectangles_atList4(void* ptr, int i)
{
	return ({ QRect tmpValue = ({QRect tmp = static_cast<QVector<QRect>*>(ptr)->at(i); if (i == static_cast<QVector<QRect>*>(ptr)->size()-1) { static_cast<QVector<QRect>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QStylePainter___drawRects_rectangles_setList4(void* ptr, void* i)
{
	static_cast<QVector<QRect>*>(ptr)->append(*static_cast<QRect*>(i));
}

void* QStylePainter___drawRects_rectangles_newList4(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<QRect>();
}

class MyQStylePlugin: public QStylePlugin
{
public:
	MyQStylePlugin(QObject *parent = Q_NULLPTR) : QStylePlugin(parent) {QStylePlugin_QStylePlugin_QRegisterMetaType();};
	QStyle * create(const QString & key) { QByteArray* ta62f22 = new QByteArray(key.toUtf8()); QtWidgets_PackedString keyPacked = { const_cast<char*>(ta62f22->prepend("WHITESPACE").constData()+10), ta62f22->size()-10, ta62f22 };return static_cast<QStyle*>(callbackQStylePlugin_Create(this, keyPacked)); };
	 ~MyQStylePlugin() { callbackQStylePlugin_DestroyQStylePlugin(this); };
	void childEvent(QChildEvent * event) { callbackQStylePlugin_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQStylePlugin_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQStylePlugin_CustomEvent(this, event); };
	void deleteLater() { callbackQStylePlugin_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQStylePlugin_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQStylePlugin_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQStylePlugin_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQStylePlugin_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStylePlugin_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQStylePlugin_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQStylePlugin_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QStylePlugin*)
Q_DECLARE_METATYPE(MyQStylePlugin*)

int QStylePlugin_QStylePlugin_QRegisterMetaType(){qRegisterMetaType<QStylePlugin*>(); return qRegisterMetaType<MyQStylePlugin*>();}

void* QStylePlugin_NewQStylePlugin(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQStylePlugin(static_cast<QWindow*>(parent));
	} else {
		return new MyQStylePlugin(static_cast<QObject*>(parent));
	}
}

void* QStylePlugin_Create(void* ptr, struct QtWidgets_PackedString key)
{
	return static_cast<QStylePlugin*>(ptr)->create(QString::fromUtf8(key.data, key.len));
}

void QStylePlugin_DestroyQStylePlugin(void* ptr)
{
	static_cast<QStylePlugin*>(ptr)->~QStylePlugin();
}

void QStylePlugin_DestroyQStylePluginDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QStylePlugin___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QStylePlugin___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QStylePlugin___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QStylePlugin___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QStylePlugin___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QStylePlugin___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QStylePlugin___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

void QStylePlugin_DeleteLaterDefault(void* ptr)
{
		static_cast<QStylePlugin*>(ptr)->QStylePlugin::deleteLater();
}

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

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

char QStylePlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QStylePlugin*>(ptr)->QStylePlugin::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QStylePlugin*>(ptr)->QStylePlugin::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QStylePlugin*>(ptr)->QStylePlugin::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QStylePlugin*>(ptr)->QStylePlugin::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QStylePlugin*>(ptr)->QStylePlugin::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQStyledItemDelegate: public QStyledItemDelegate
{
public:
	MyQStyledItemDelegate(QObject *parent = Q_NULLPTR) : QStyledItemDelegate(parent) {QStyledItemDelegate_QStyledItemDelegate_QRegisterMetaType();};
	QWidget * createEditor(QWidget * parent, const QStyleOptionViewItem & option, const QModelIndex & index) const { return static_cast<QWidget*>(callbackQAbstractItemDelegate_CreateEditor(const_cast<void*>(static_cast<const void*>(this)), parent, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index))); };
	QString displayText(const QVariant & value, const QLocale & locale) const { return ({ QtWidgets_PackedString tempVal = callbackQStyledItemDelegate_DisplayText(const_cast<void*>(static_cast<const void*>(this)), const_cast<QVariant*>(&value), const_cast<QLocale*>(&locale)); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	bool editorEvent(QEvent * event, QAbstractItemModel * model, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQAbstractItemDelegate_EditorEvent(this, event, model, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)) != 0; };
	bool eventFilter(QObject * editor, QEvent * event) { return callbackQAbstractItemDelegate_EventFilter(this, editor, event) != 0; };
	void initStyleOption(QStyleOptionViewItem * option, const QModelIndex & index) const { callbackQStyledItemDelegate_InitStyleOption(const_cast<void*>(static_cast<const void*>(this)), option, const_cast<QModelIndex*>(&index)); };
	void paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQStyledItemDelegate_Paint(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	void setEditorData(QWidget * editor, const QModelIndex & index) const { callbackQAbstractItemDelegate_SetEditorData(const_cast<void*>(static_cast<const void*>(this)), editor, const_cast<QModelIndex*>(&index)); };
	void setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex & index) const { callbackQAbstractItemDelegate_SetModelData(const_cast<void*>(static_cast<const void*>(this)), editor, model, const_cast<QModelIndex*>(&index)); };
	QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex & index) const { return *static_cast<QSize*>(callbackQStyledItemDelegate_SizeHint(const_cast<void*>(static_cast<const void*>(this)), const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index))); };
	void updateEditorGeometry(QWidget * editor, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQAbstractItemDelegate_UpdateEditorGeometry(const_cast<void*>(static_cast<const void*>(this)), editor, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	 ~MyQStyledItemDelegate() { callbackQStyledItemDelegate_DestroyQStyledItemDelegate(this); };
	void Signal_CloseEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemDelegate_CloseEditor(this, editor, hint); };
	void Signal_CommitData(QWidget * editor) { callbackQAbstractItemDelegate_CommitData(this, editor); };
	void destroyEditor(QWidget * editor, const QModelIndex & index) const { callbackQAbstractItemDelegate_DestroyEditor(const_cast<void*>(static_cast<const void*>(this)), editor, const_cast<QModelIndex*>(&index)); };
	bool helpEvent(QHelpEvent * event, QAbstractItemView * view, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQAbstractItemDelegate_HelpEvent(this, event, view, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)) != 0; };
	void Signal_SizeHintChanged(const QModelIndex & index) { callbackQAbstractItemDelegate_SizeHintChanged(this, const_cast<QModelIndex*>(&index)); };
	void childEvent(QChildEvent * event) { callbackQAbstractItemDelegate_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractItemDelegate_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractItemDelegate_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractItemDelegate_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAbstractItemDelegate_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractItemDelegate_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQAbstractItemDelegate_Event(this, e) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractItemDelegate_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAbstractItemDelegate_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAbstractItemDelegate_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QStyledItemDelegate*)
Q_DECLARE_METATYPE(MyQStyledItemDelegate*)

int QStyledItemDelegate_QStyledItemDelegate_QRegisterMetaType(){qRegisterMetaType<QStyledItemDelegate*>(); return qRegisterMetaType<MyQStyledItemDelegate*>();}

void* QStyledItemDelegate_NewQStyledItemDelegate(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQStyledItemDelegate(static_cast<QWindow*>(parent));
	} else {
		return new MyQStyledItemDelegate(static_cast<QObject*>(parent));
	}
}

struct QtWidgets_PackedString QStyledItemDelegate_DisplayText(void* ptr, void* value, void* locale)
{
	return ({ QByteArray* t4b31fe = new QByteArray(static_cast<QStyledItemDelegate*>(ptr)->displayText(*static_cast<QVariant*>(value), *static_cast<QLocale*>(locale)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t4b31fe->prepend("WHITESPACE").constData()+10), t4b31fe->size()-10, t4b31fe }; });
}

struct QtWidgets_PackedString QStyledItemDelegate_DisplayTextDefault(void* ptr, void* value, void* locale)
{
		return ({ QByteArray* tfa980a = new QByteArray(static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::displayText(*static_cast<QVariant*>(value), *static_cast<QLocale*>(locale)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tfa980a->prepend("WHITESPACE").constData()+10), tfa980a->size()-10, tfa980a }; });
}

void QStyledItemDelegate_InitStyleOption(void* ptr, void* option, void* index)
{
	static_cast<QStyledItemDelegate*>(ptr)->initStyleOption(static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QStyledItemDelegate_InitStyleOptionDefault(void* ptr, void* option, void* index)
{
		static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::initStyleOption(static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void* QStyledItemDelegate_ItemEditorFactory(void* ptr)
{
	return static_cast<QStyledItemDelegate*>(ptr)->itemEditorFactory();
}

void QStyledItemDelegate_Paint(void* ptr, void* painter, void* option, void* index)
{
	static_cast<QStyledItemDelegate*>(ptr)->paint(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QStyledItemDelegate_PaintDefault(void* ptr, void* painter, void* option, void* index)
{
		static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::paint(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QStyledItemDelegate_SetItemEditorFactory(void* ptr, void* factory)
{
	static_cast<QStyledItemDelegate*>(ptr)->setItemEditorFactory(static_cast<QItemEditorFactory*>(factory));
}

void* QStyledItemDelegate_SizeHint(void* ptr, void* option, void* index)
{
	return ({ QSize tmpValue = static_cast<QStyledItemDelegate*>(ptr)->sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QStyledItemDelegate_SizeHintDefault(void* ptr, void* option, void* index)
{
		return ({ QSize tmpValue = static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStyledItemDelegate_DestroyQStyledItemDelegate(void* ptr)
{
	static_cast<QStyledItemDelegate*>(ptr)->~QStyledItemDelegate();
}

void QStyledItemDelegate_DestroyQStyledItemDelegateDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQSwipeGesture: public QSwipeGesture
{
public:
	 ~MyQSwipeGesture() { callbackQSwipeGesture_DestroyQSwipeGesture(this); };
	void childEvent(QChildEvent * event) { callbackQGesture_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGesture_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGesture_CustomEvent(this, event); };
	void deleteLater() { callbackQGesture_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGesture_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGesture_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGesture_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGesture_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGesture_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGesture_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGesture_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QSwipeGesture*)
Q_DECLARE_METATYPE(MyQSwipeGesture*)

int QSwipeGesture_QSwipeGesture_QRegisterMetaType(){qRegisterMetaType<QSwipeGesture*>(); return qRegisterMetaType<MyQSwipeGesture*>();}

long long QSwipeGesture_HorizontalDirection(void* ptr)
{
	return static_cast<QSwipeGesture*>(ptr)->horizontalDirection();
}

void QSwipeGesture_SetSwipeAngle(void* ptr, double value)
{
	static_cast<QSwipeGesture*>(ptr)->setSwipeAngle(value);
}

double QSwipeGesture_SwipeAngle(void* ptr)
{
	return static_cast<QSwipeGesture*>(ptr)->swipeAngle();
}

long long QSwipeGesture_VerticalDirection(void* ptr)
{
	return static_cast<QSwipeGesture*>(ptr)->verticalDirection();
}

void QSwipeGesture_DestroyQSwipeGesture(void* ptr)
{
	static_cast<QSwipeGesture*>(ptr)->~QSwipeGesture();
}

void QSwipeGesture_DestroyQSwipeGestureDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQSystemTrayIcon: public QSystemTrayIcon
{
public:
	MyQSystemTrayIcon(QObject *parent = Q_NULLPTR) : QSystemTrayIcon(parent) {QSystemTrayIcon_QSystemTrayIcon_QRegisterMetaType();};
	MyQSystemTrayIcon(const QIcon &icon, QObject *parent = Q_NULLPTR) : QSystemTrayIcon(icon, parent) {QSystemTrayIcon_QSystemTrayIcon_QRegisterMetaType();};
	void Signal_Activated(QSystemTrayIcon::ActivationReason reason) { callbackQSystemTrayIcon_Activated(this, reason); };
	bool event(QEvent * e) { return callbackQSystemTrayIcon_Event(this, e) != 0; };
	void hide() { callbackQSystemTrayIcon_Hide(this); };
	void Signal_MessageClicked() { callbackQSystemTrayIcon_MessageClicked(this); };
	void setVisible(bool visible) { callbackQSystemTrayIcon_SetVisible(this, visible); };
	void show() { callbackQSystemTrayIcon_Show(this); };
	void showMessage(const QString & title, const QString & message, QSystemTrayIcon::MessageIcon icon, int millisecondsTimeoutHint) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };QByteArray* t6f9b9a = new QByteArray(message.toUtf8()); QtWidgets_PackedString messagePacked = { const_cast<char*>(t6f9b9a->prepend("WHITESPACE").constData()+10), t6f9b9a->size()-10, t6f9b9a };callbackQSystemTrayIcon_ShowMessage(this, titlePacked, messagePacked, icon, millisecondsTimeoutHint); };
	void showMessage(const QString & title, const QString & message, const QIcon & icon, int millisecondsTimeoutHint) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };QByteArray* t6f9b9a = new QByteArray(message.toUtf8()); QtWidgets_PackedString messagePacked = { const_cast<char*>(t6f9b9a->prepend("WHITESPACE").constData()+10), t6f9b9a->size()-10, t6f9b9a };callbackQSystemTrayIcon_ShowMessage2(this, titlePacked, messagePacked, const_cast<QIcon*>(&icon), millisecondsTimeoutHint); };
	 ~MyQSystemTrayIcon() { callbackQSystemTrayIcon_DestroyQSystemTrayIcon(this); };
	void childEvent(QChildEvent * event) { callbackQSystemTrayIcon_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQSystemTrayIcon_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQSystemTrayIcon_CustomEvent(this, event); };
	void deleteLater() { callbackQSystemTrayIcon_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQSystemTrayIcon_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQSystemTrayIcon_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSystemTrayIcon_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSystemTrayIcon_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQSystemTrayIcon_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQSystemTrayIcon_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QSystemTrayIcon*)
Q_DECLARE_METATYPE(MyQSystemTrayIcon*)

int QSystemTrayIcon_QSystemTrayIcon_QRegisterMetaType(){qRegisterMetaType<QSystemTrayIcon*>(); return qRegisterMetaType<MyQSystemTrayIcon*>();}

void* QSystemTrayIcon_NewQSystemTrayIcon(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(static_cast<QWindow*>(parent));
	} else {
		return new MyQSystemTrayIcon(static_cast<QObject*>(parent));
	}
}

void* QSystemTrayIcon_NewQSystemTrayIcon2(void* icon, void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QWindow*>(parent));
	} else {
		return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QObject*>(parent));
	}
}

void QSystemTrayIcon_ConnectActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QSystemTrayIcon*>(ptr), static_cast<void (QSystemTrayIcon::*)(QSystemTrayIcon::ActivationReason)>(&QSystemTrayIcon::activated), static_cast<MyQSystemTrayIcon*>(ptr), static_cast<void (MyQSystemTrayIcon::*)(QSystemTrayIcon::ActivationReason)>(&MyQSystemTrayIcon::Signal_Activated), static_cast<Qt::ConnectionType>(t));
}

void QSystemTrayIcon_DisconnectActivated(void* ptr)
{
	QObject::disconnect(static_cast<QSystemTrayIcon*>(ptr), static_cast<void (QSystemTrayIcon::*)(QSystemTrayIcon::ActivationReason)>(&QSystemTrayIcon::activated), static_cast<MyQSystemTrayIcon*>(ptr), static_cast<void (MyQSystemTrayIcon::*)(QSystemTrayIcon::ActivationReason)>(&MyQSystemTrayIcon::Signal_Activated));
}

void QSystemTrayIcon_Activated(void* ptr, long long reason)
{
	static_cast<QSystemTrayIcon*>(ptr)->activated(static_cast<QSystemTrayIcon::ActivationReason>(reason));
}

void* QSystemTrayIcon_ContextMenu(void* ptr)
{
	return static_cast<QSystemTrayIcon*>(ptr)->contextMenu();
}

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

void* QSystemTrayIcon_Geometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QSystemTrayIcon*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QSystemTrayIcon_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSystemTrayIcon*>(ptr), "hide");
}

void QSystemTrayIcon_HideDefault(void* ptr)
{
		static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::hide();
}

void* QSystemTrayIcon_Icon(void* ptr)
{
	return new QIcon(static_cast<QSystemTrayIcon*>(ptr)->icon());
}

char QSystemTrayIcon_QSystemTrayIcon_IsSystemTrayAvailable()
{
	return QSystemTrayIcon::isSystemTrayAvailable();
}

char QSystemTrayIcon_IsVisible(void* ptr)
{
	return static_cast<QSystemTrayIcon*>(ptr)->isVisible();
}

void QSystemTrayIcon_ConnectMessageClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QSystemTrayIcon*>(ptr), static_cast<void (QSystemTrayIcon::*)()>(&QSystemTrayIcon::messageClicked), static_cast<MyQSystemTrayIcon*>(ptr), static_cast<void (MyQSystemTrayIcon::*)()>(&MyQSystemTrayIcon::Signal_MessageClicked), static_cast<Qt::ConnectionType>(t));
}

void QSystemTrayIcon_DisconnectMessageClicked(void* ptr)
{
	QObject::disconnect(static_cast<QSystemTrayIcon*>(ptr), static_cast<void (QSystemTrayIcon::*)()>(&QSystemTrayIcon::messageClicked), static_cast<MyQSystemTrayIcon*>(ptr), static_cast<void (MyQSystemTrayIcon::*)()>(&MyQSystemTrayIcon::Signal_MessageClicked));
}

void QSystemTrayIcon_MessageClicked(void* ptr)
{
	static_cast<QSystemTrayIcon*>(ptr)->messageClicked();
}

void QSystemTrayIcon_SetContextMenu(void* ptr, void* menu)
{
	static_cast<QSystemTrayIcon*>(ptr)->setContextMenu(static_cast<QMenu*>(menu));
}

void QSystemTrayIcon_SetIcon(void* ptr, void* icon)
{
	static_cast<QSystemTrayIcon*>(ptr)->setIcon(*static_cast<QIcon*>(icon));
}

void QSystemTrayIcon_SetToolTip(void* ptr, struct QtWidgets_PackedString tip)
{
	static_cast<QSystemTrayIcon*>(ptr)->setToolTip(QString::fromUtf8(tip.data, tip.len));
}

void QSystemTrayIcon_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QSystemTrayIcon*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QSystemTrayIcon_SetVisibleDefault(void* ptr, char visible)
{
		static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::setVisible(visible != 0);
}

void QSystemTrayIcon_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSystemTrayIcon*>(ptr), "show");
}

void QSystemTrayIcon_ShowDefault(void* ptr)
{
		static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::show();
}

void QSystemTrayIcon_ShowMessage(void* ptr, struct QtWidgets_PackedString title, struct QtWidgets_PackedString message, long long icon, int millisecondsTimeoutHint)
{
	QMetaObject::invokeMethod(static_cast<QSystemTrayIcon*>(ptr), "showMessage", Q_ARG(const QString, QString::fromUtf8(title.data, title.len)), Q_ARG(const QString, QString::fromUtf8(message.data, message.len)), Q_ARG(QSystemTrayIcon::MessageIcon, static_cast<QSystemTrayIcon::MessageIcon>(icon)), Q_ARG(int, millisecondsTimeoutHint));
}

void QSystemTrayIcon_ShowMessageDefault(void* ptr, struct QtWidgets_PackedString title, struct QtWidgets_PackedString message, long long icon, int millisecondsTimeoutHint)
{
		static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::showMessage(QString::fromUtf8(title.data, title.len), QString::fromUtf8(message.data, message.len), static_cast<QSystemTrayIcon::MessageIcon>(icon), millisecondsTimeoutHint);
}

void QSystemTrayIcon_ShowMessage2(void* ptr, struct QtWidgets_PackedString title, struct QtWidgets_PackedString message, void* icon, int millisecondsTimeoutHint)
{
	QMetaObject::invokeMethod(static_cast<QSystemTrayIcon*>(ptr), "showMessage", Q_ARG(const QString, QString::fromUtf8(title.data, title.len)), Q_ARG(const QString, QString::fromUtf8(message.data, message.len)), Q_ARG(const QIcon, *static_cast<QIcon*>(icon)), Q_ARG(int, millisecondsTimeoutHint));
}

void QSystemTrayIcon_ShowMessage2Default(void* ptr, struct QtWidgets_PackedString title, struct QtWidgets_PackedString message, void* icon, int millisecondsTimeoutHint)
{
		static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::showMessage(QString::fromUtf8(title.data, title.len), QString::fromUtf8(message.data, message.len), *static_cast<QIcon*>(icon), millisecondsTimeoutHint);
}

char QSystemTrayIcon_QSystemTrayIcon_SupportsMessages()
{
	return QSystemTrayIcon::supportsMessages();
}

struct QtWidgets_PackedString QSystemTrayIcon_ToolTip(void* ptr)
{
	return ({ QByteArray* t27041f = new QByteArray(static_cast<QSystemTrayIcon*>(ptr)->toolTip().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t27041f->prepend("WHITESPACE").constData()+10), t27041f->size()-10, t27041f }; });
}

void QSystemTrayIcon_DestroyQSystemTrayIcon(void* ptr)
{
	static_cast<QSystemTrayIcon*>(ptr)->~QSystemTrayIcon();
}

void QSystemTrayIcon_DestroyQSystemTrayIconDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QSystemTrayIcon___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QSystemTrayIcon___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QSystemTrayIcon___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QSystemTrayIcon___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QSystemTrayIcon___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QSystemTrayIcon___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QSystemTrayIcon___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

void QSystemTrayIcon_DeleteLaterDefault(void* ptr)
{
		static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::deleteLater();
}

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

char QSystemTrayIcon_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQTabBar: public QTabBar
{
public:
	MyQTabBar(QWidget *parent = Q_NULLPTR) : QTabBar(parent) {QTabBar_QTabBar_QRegisterMetaType();};
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	void Signal_CurrentChanged(int index) { callbackQTabBar_CurrentChanged(this, index); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void hideEvent(QHideEvent * vqh) { callbackQWidget_HideEvent(this, vqh); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize minimumTabSizeHint(int index) const { return *static_cast<QSize*>(callbackQTabBar_MinimumTabSizeHint(const_cast<void*>(static_cast<const void*>(this)), index)); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
	void resizeEvent(QResizeEvent * vqr) { callbackQWidget_ResizeEvent(this, vqr); };
	void setCurrentIndex(int index) { callbackQTabBar_SetCurrentIndex(this, index); };
	void showEvent(QShowEvent * vqs) { callbackQWidget_ShowEvent(this, vqs); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_TabBarClicked(int index) { callbackQTabBar_TabBarClicked(this, index); };
	void Signal_TabBarDoubleClicked(int index) { callbackQTabBar_TabBarDoubleClicked(this, index); };
	void Signal_TabCloseRequested(int index) { callbackQTabBar_TabCloseRequested(this, index); };
	void tabInserted(int index) { callbackQTabBar_TabInserted(this, index); };
	void tabLayoutChange() { callbackQTabBar_TabLayoutChange(this); };
	void Signal_TabMoved(int from, int to) { callbackQTabBar_TabMoved(this, from, to); };
	void tabRemoved(int index) { callbackQTabBar_TabRemoved(this, index); };
	QSize tabSizeHint(int index) const { return *static_cast<QSize*>(callbackQTabBar_TabSizeHint(const_cast<void*>(static_cast<const void*>(this)), index)); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	 ~MyQTabBar() { callbackQTabBar_DestroyQTabBar(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QTabBar*)
Q_DECLARE_METATYPE(MyQTabBar*)

int QTabBar_QTabBar_QRegisterMetaType(){qRegisterMetaType<QTabBar*>(); return qRegisterMetaType<MyQTabBar*>();}

void* QTabBar_NewQTabBar(void* parent)
{
		return new MyQTabBar(static_cast<QWidget*>(parent));
}

struct QtWidgets_PackedString QTabBar_AccessibleTabName(void* ptr, int index)
{
	return ({ QByteArray* tfff4ba = new QByteArray(static_cast<QTabBar*>(ptr)->accessibleTabName(index).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tfff4ba->prepend("WHITESPACE").constData()+10), tfff4ba->size()-10, tfff4ba }; });
}

int QTabBar_AddTab(void* ptr, struct QtWidgets_PackedString text)
{
	return static_cast<QTabBar*>(ptr)->addTab(QString::fromUtf8(text.data, text.len));
}

int QTabBar_AddTab2(void* ptr, void* icon, struct QtWidgets_PackedString text)
{
	return static_cast<QTabBar*>(ptr)->addTab(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len));
}

char QTabBar_AutoHide(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->autoHide();
}

char QTabBar_ChangeCurrentOnDrag(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->changeCurrentOnDrag();
}

int QTabBar_Count(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->count();
}

void QTabBar_ConnectCurrentChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTabBar*>(ptr), static_cast<void (QTabBar::*)(int)>(&QTabBar::currentChanged), static_cast<MyQTabBar*>(ptr), static_cast<void (MyQTabBar::*)(int)>(&MyQTabBar::Signal_CurrentChanged), static_cast<Qt::ConnectionType>(t));
}

void QTabBar_DisconnectCurrentChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTabBar*>(ptr), static_cast<void (QTabBar::*)(int)>(&QTabBar::currentChanged), static_cast<MyQTabBar*>(ptr), static_cast<void (MyQTabBar::*)(int)>(&MyQTabBar::Signal_CurrentChanged));
}

void QTabBar_CurrentChanged(void* ptr, int index)
{
	static_cast<QTabBar*>(ptr)->currentChanged(index);
}

int QTabBar_CurrentIndex(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->currentIndex();
}

char QTabBar_DocumentMode(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->documentMode();
}

char QTabBar_DrawBase(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->drawBase();
}

long long QTabBar_ElideMode(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->elideMode();
}

char QTabBar_Expanding(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->expanding();
}

void* QTabBar_IconSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTabBar*>(ptr)->iconSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTabBar_InitStyleOption(void* ptr, void* option, int tabIndex)
{
	static_cast<QTabBar*>(ptr)->initStyleOption(static_cast<QStyleOptionTab*>(option), tabIndex);
}

int QTabBar_InsertTab(void* ptr, int index, struct QtWidgets_PackedString text)
{
	return static_cast<QTabBar*>(ptr)->insertTab(index, QString::fromUtf8(text.data, text.len));
}

int QTabBar_InsertTab2(void* ptr, int index, void* icon, struct QtWidgets_PackedString text)
{
	return static_cast<QTabBar*>(ptr)->insertTab(index, *static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len));
}

char QTabBar_IsMovable(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->isMovable();
}

char QTabBar_IsTabEnabled(void* ptr, int index)
{
	return static_cast<QTabBar*>(ptr)->isTabEnabled(index);
}

void* QTabBar_MinimumTabSizeHint(void* ptr, int index)
{
	return ({ QSize tmpValue = static_cast<QTabBar*>(ptr)->minimumTabSizeHint(index); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTabBar_MinimumTabSizeHintDefault(void* ptr, int index)
{
		return ({ QSize tmpValue = static_cast<QTabBar*>(ptr)->QTabBar::minimumTabSizeHint(index); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTabBar_MoveTab(void* ptr, int from, int to)
{
	static_cast<QTabBar*>(ptr)->moveTab(from, to);
}

void QTabBar_RemoveTab(void* ptr, int index)
{
	static_cast<QTabBar*>(ptr)->removeTab(index);
}

long long QTabBar_SelectionBehaviorOnRemove(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->selectionBehaviorOnRemove();
}

void QTabBar_SetAccessibleTabName(void* ptr, int index, struct QtWidgets_PackedString name)
{
	static_cast<QTabBar*>(ptr)->setAccessibleTabName(index, QString::fromUtf8(name.data, name.len));
}

void QTabBar_SetAutoHide(void* ptr, char hide)
{
	static_cast<QTabBar*>(ptr)->setAutoHide(hide != 0);
}

void QTabBar_SetChangeCurrentOnDrag(void* ptr, char change)
{
	static_cast<QTabBar*>(ptr)->setChangeCurrentOnDrag(change != 0);
}

void QTabBar_SetCurrentIndex(void* ptr, int index)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setCurrentIndex", Q_ARG(int, index));
}

void QTabBar_SetCurrentIndexDefault(void* ptr, int index)
{
		static_cast<QTabBar*>(ptr)->QTabBar::setCurrentIndex(index);
}

void QTabBar_SetDocumentMode(void* ptr, char set)
{
	static_cast<QTabBar*>(ptr)->setDocumentMode(set != 0);
}

void QTabBar_SetDrawBase(void* ptr, char drawTheBase)
{
	static_cast<QTabBar*>(ptr)->setDrawBase(drawTheBase != 0);
}

void QTabBar_SetElideMode(void* ptr, long long vqt)
{
	static_cast<QTabBar*>(ptr)->setElideMode(static_cast<Qt::TextElideMode>(vqt));
}

void QTabBar_SetExpanding(void* ptr, char enabled)
{
	static_cast<QTabBar*>(ptr)->setExpanding(enabled != 0);
}

void QTabBar_SetIconSize(void* ptr, void* size)
{
	static_cast<QTabBar*>(ptr)->setIconSize(*static_cast<QSize*>(size));
}

void QTabBar_SetMovable(void* ptr, char movable)
{
	static_cast<QTabBar*>(ptr)->setMovable(movable != 0);
}

void QTabBar_SetSelectionBehaviorOnRemove(void* ptr, long long behavior)
{
	static_cast<QTabBar*>(ptr)->setSelectionBehaviorOnRemove(static_cast<QTabBar::SelectionBehavior>(behavior));
}

void QTabBar_SetShape(void* ptr, long long shape)
{
	static_cast<QTabBar*>(ptr)->setShape(static_cast<QTabBar::Shape>(shape));
}

void QTabBar_SetTabButton(void* ptr, int index, long long position, void* widget)
{
		static_cast<QTabBar*>(ptr)->setTabButton(index, static_cast<QTabBar::ButtonPosition>(position), static_cast<QWidget*>(widget));
}

void QTabBar_SetTabData(void* ptr, int index, void* data)
{
	static_cast<QTabBar*>(ptr)->setTabData(index, *static_cast<QVariant*>(data));
}

void QTabBar_SetTabEnabled(void* ptr, int index, char enabled)
{
	static_cast<QTabBar*>(ptr)->setTabEnabled(index, enabled != 0);
}

void QTabBar_SetTabIcon(void* ptr, int index, void* icon)
{
	static_cast<QTabBar*>(ptr)->setTabIcon(index, *static_cast<QIcon*>(icon));
}

void QTabBar_SetTabText(void* ptr, int index, struct QtWidgets_PackedString text)
{
	static_cast<QTabBar*>(ptr)->setTabText(index, QString::fromUtf8(text.data, text.len));
}

void QTabBar_SetTabTextColor(void* ptr, int index, void* color)
{
	static_cast<QTabBar*>(ptr)->setTabTextColor(index, *static_cast<QColor*>(color));
}

void QTabBar_SetTabToolTip(void* ptr, int index, struct QtWidgets_PackedString tip)
{
	static_cast<QTabBar*>(ptr)->setTabToolTip(index, QString::fromUtf8(tip.data, tip.len));
}

void QTabBar_SetTabWhatsThis(void* ptr, int index, struct QtWidgets_PackedString text)
{
	static_cast<QTabBar*>(ptr)->setTabWhatsThis(index, QString::fromUtf8(text.data, text.len));
}

void QTabBar_SetTabsClosable(void* ptr, char closable)
{
	static_cast<QTabBar*>(ptr)->setTabsClosable(closable != 0);
}

void QTabBar_SetUsesScrollButtons(void* ptr, char useButtons)
{
	static_cast<QTabBar*>(ptr)->setUsesScrollButtons(useButtons != 0);
}

long long QTabBar_Shape(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->shape();
}

int QTabBar_TabAt(void* ptr, void* position)
{
	return static_cast<QTabBar*>(ptr)->tabAt(*static_cast<QPoint*>(position));
}

void QTabBar_ConnectTabBarClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QTabBar*>(ptr), static_cast<void (QTabBar::*)(int)>(&QTabBar::tabBarClicked), static_cast<MyQTabBar*>(ptr), static_cast<void (MyQTabBar::*)(int)>(&MyQTabBar::Signal_TabBarClicked), static_cast<Qt::ConnectionType>(t));
}

void QTabBar_DisconnectTabBarClicked(void* ptr)
{
	QObject::disconnect(static_cast<QTabBar*>(ptr), static_cast<void (QTabBar::*)(int)>(&QTabBar::tabBarClicked), static_cast<MyQTabBar*>(ptr), static_cast<void (MyQTabBar::*)(int)>(&MyQTabBar::Signal_TabBarClicked));
}

void QTabBar_TabBarClicked(void* ptr, int index)
{
	static_cast<QTabBar*>(ptr)->tabBarClicked(index);
}

void QTabBar_ConnectTabBarDoubleClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QTabBar*>(ptr), static_cast<void (QTabBar::*)(int)>(&QTabBar::tabBarDoubleClicked), static_cast<MyQTabBar*>(ptr), static_cast<void (MyQTabBar::*)(int)>(&MyQTabBar::Signal_TabBarDoubleClicked), static_cast<Qt::ConnectionType>(t));
}

void QTabBar_DisconnectTabBarDoubleClicked(void* ptr)
{
	QObject::disconnect(static_cast<QTabBar*>(ptr), static_cast<void (QTabBar::*)(int)>(&QTabBar::tabBarDoubleClicked), static_cast<MyQTabBar*>(ptr), static_cast<void (MyQTabBar::*)(int)>(&MyQTabBar::Signal_TabBarDoubleClicked));
}

void QTabBar_TabBarDoubleClicked(void* ptr, int index)
{
	static_cast<QTabBar*>(ptr)->tabBarDoubleClicked(index);
}

void* QTabBar_TabButton(void* ptr, int index, long long position)
{
	return static_cast<QTabBar*>(ptr)->tabButton(index, static_cast<QTabBar::ButtonPosition>(position));
}

void QTabBar_ConnectTabCloseRequested(void* ptr, long long t)
{
	QObject::connect(static_cast<QTabBar*>(ptr), static_cast<void (QTabBar::*)(int)>(&QTabBar::tabCloseRequested), static_cast<MyQTabBar*>(ptr), static_cast<void (MyQTabBar::*)(int)>(&MyQTabBar::Signal_TabCloseRequested), static_cast<Qt::ConnectionType>(t));
}

void QTabBar_DisconnectTabCloseRequested(void* ptr)
{
	QObject::disconnect(static_cast<QTabBar*>(ptr), static_cast<void (QTabBar::*)(int)>(&QTabBar::tabCloseRequested), static_cast<MyQTabBar*>(ptr), static_cast<void (MyQTabBar::*)(int)>(&MyQTabBar::Signal_TabCloseRequested));
}

void QTabBar_TabCloseRequested(void* ptr, int index)
{
	static_cast<QTabBar*>(ptr)->tabCloseRequested(index);
}

void* QTabBar_TabData(void* ptr, int index)
{
	return new QVariant(static_cast<QTabBar*>(ptr)->tabData(index));
}

void* QTabBar_TabIcon(void* ptr, int index)
{
	return new QIcon(static_cast<QTabBar*>(ptr)->tabIcon(index));
}

void QTabBar_TabInserted(void* ptr, int index)
{
	static_cast<QTabBar*>(ptr)->tabInserted(index);
}

void QTabBar_TabInsertedDefault(void* ptr, int index)
{
		static_cast<QTabBar*>(ptr)->QTabBar::tabInserted(index);
}

void QTabBar_TabLayoutChange(void* ptr)
{
	static_cast<QTabBar*>(ptr)->tabLayoutChange();
}

void QTabBar_TabLayoutChangeDefault(void* ptr)
{
		static_cast<QTabBar*>(ptr)->QTabBar::tabLayoutChange();
}

void QTabBar_ConnectTabMoved(void* ptr, long long t)
{
	QObject::connect(static_cast<QTabBar*>(ptr), static_cast<void (QTabBar::*)(int, int)>(&QTabBar::tabMoved), static_cast<MyQTabBar*>(ptr), static_cast<void (MyQTabBar::*)(int, int)>(&MyQTabBar::Signal_TabMoved), static_cast<Qt::ConnectionType>(t));
}

void QTabBar_DisconnectTabMoved(void* ptr)
{
	QObject::disconnect(static_cast<QTabBar*>(ptr), static_cast<void (QTabBar::*)(int, int)>(&QTabBar::tabMoved), static_cast<MyQTabBar*>(ptr), static_cast<void (MyQTabBar::*)(int, int)>(&MyQTabBar::Signal_TabMoved));
}

void QTabBar_TabMoved(void* ptr, int from, int to)
{
	static_cast<QTabBar*>(ptr)->tabMoved(from, to);
}

void* QTabBar_TabRect(void* ptr, int index)
{
	return ({ QRect tmpValue = static_cast<QTabBar*>(ptr)->tabRect(index); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QTabBar_TabRemoved(void* ptr, int index)
{
	static_cast<QTabBar*>(ptr)->tabRemoved(index);
}

void QTabBar_TabRemovedDefault(void* ptr, int index)
{
		static_cast<QTabBar*>(ptr)->QTabBar::tabRemoved(index);
}

void* QTabBar_TabSizeHint(void* ptr, int index)
{
	return ({ QSize tmpValue = static_cast<QTabBar*>(ptr)->tabSizeHint(index); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTabBar_TabSizeHintDefault(void* ptr, int index)
{
		return ({ QSize tmpValue = static_cast<QTabBar*>(ptr)->QTabBar::tabSizeHint(index); new QSize(tmpValue.width(), tmpValue.height()); });
}

struct QtWidgets_PackedString QTabBar_TabText(void* ptr, int index)
{
	return ({ QByteArray* t67599e = new QByteArray(static_cast<QTabBar*>(ptr)->tabText(index).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t67599e->prepend("WHITESPACE").constData()+10), t67599e->size()-10, t67599e }; });
}

void* QTabBar_TabTextColor(void* ptr, int index)
{
	return new QColor(static_cast<QTabBar*>(ptr)->tabTextColor(index));
}

struct QtWidgets_PackedString QTabBar_TabToolTip(void* ptr, int index)
{
	return ({ QByteArray* t1438d1 = new QByteArray(static_cast<QTabBar*>(ptr)->tabToolTip(index).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t1438d1->prepend("WHITESPACE").constData()+10), t1438d1->size()-10, t1438d1 }; });
}

struct QtWidgets_PackedString QTabBar_TabWhatsThis(void* ptr, int index)
{
	return ({ QByteArray* t61711f = new QByteArray(static_cast<QTabBar*>(ptr)->tabWhatsThis(index).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t61711f->prepend("WHITESPACE").constData()+10), t61711f->size()-10, t61711f }; });
}

char QTabBar_TabsClosable(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->tabsClosable();
}

char QTabBar_UsesScrollButtons(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->usesScrollButtons();
}

void QTabBar_DestroyQTabBar(void* ptr)
{
	static_cast<QTabBar*>(ptr)->~QTabBar();
}

void QTabBar_DestroyQTabBarDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQTabWidget: public QTabWidget
{
public:
	MyQTabWidget(QWidget *parent = Q_NULLPTR) : QTabWidget(parent) {QTabWidget_QTabWidget_QRegisterMetaType();};
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void Signal_CurrentChanged(int index) { callbackQTabWidget_CurrentChanged(this, index); };
	bool event(QEvent * ev) { return callbackQWidget_Event(this, ev) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int width) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), width); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void setCurrentIndex(int index) { callbackQTabWidget_SetCurrentIndex(this, index); };
	void setCurrentWidget(QWidget * widget) { callbackQTabWidget_SetCurrentWidget(this, widget); };
	void showEvent(QShowEvent * vqs) { callbackQWidget_ShowEvent(this, vqs); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_TabBarClicked(int index) { callbackQTabWidget_TabBarClicked(this, index); };
	void Signal_TabBarDoubleClicked(int index) { callbackQTabWidget_TabBarDoubleClicked(this, index); };
	void Signal_TabCloseRequested(int index) { callbackQTabWidget_TabCloseRequested(this, index); };
	void tabInserted(int index) { callbackQTabWidget_TabInserted(this, index); };
	void tabRemoved(int index) { callbackQTabWidget_TabRemoved(this, index); };
	 ~MyQTabWidget() { callbackQTabWidget_DestroyQTabWidget(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QTabWidget*)
Q_DECLARE_METATYPE(MyQTabWidget*)

int QTabWidget_QTabWidget_QRegisterMetaType(){qRegisterMetaType<QTabWidget*>(); return qRegisterMetaType<MyQTabWidget*>();}

void* QTabWidget_NewQTabWidget(void* parent)
{
		return new MyQTabWidget(static_cast<QWidget*>(parent));
}

int QTabWidget_AddTab(void* ptr, void* page, struct QtWidgets_PackedString label)
{
		return static_cast<QTabWidget*>(ptr)->addTab(static_cast<QWidget*>(page), QString::fromUtf8(label.data, label.len));
}

int QTabWidget_AddTab2(void* ptr, void* page, void* icon, struct QtWidgets_PackedString label)
{
		return static_cast<QTabWidget*>(ptr)->addTab(static_cast<QWidget*>(page), *static_cast<QIcon*>(icon), QString::fromUtf8(label.data, label.len));
}

void QTabWidget_Clear(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->clear();
}

void* QTabWidget_CornerWidget(void* ptr, long long corner)
{
	return static_cast<QTabWidget*>(ptr)->cornerWidget(static_cast<Qt::Corner>(corner));
}

int QTabWidget_Count(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->count();
}

void QTabWidget_ConnectCurrentChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTabWidget*>(ptr), static_cast<void (QTabWidget::*)(int)>(&QTabWidget::currentChanged), static_cast<MyQTabWidget*>(ptr), static_cast<void (MyQTabWidget::*)(int)>(&MyQTabWidget::Signal_CurrentChanged), static_cast<Qt::ConnectionType>(t));
}

void QTabWidget_DisconnectCurrentChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTabWidget*>(ptr), static_cast<void (QTabWidget::*)(int)>(&QTabWidget::currentChanged), static_cast<MyQTabWidget*>(ptr), static_cast<void (MyQTabWidget::*)(int)>(&MyQTabWidget::Signal_CurrentChanged));
}

void QTabWidget_CurrentChanged(void* ptr, int index)
{
	static_cast<QTabWidget*>(ptr)->currentChanged(index);
}

int QTabWidget_CurrentIndex(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->currentIndex();
}

void* QTabWidget_CurrentWidget(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->currentWidget();
}

char QTabWidget_DocumentMode(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->documentMode();
}

long long QTabWidget_ElideMode(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->elideMode();
}

void* QTabWidget_IconSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTabWidget*>(ptr)->iconSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QTabWidget_IndexOf(void* ptr, void* w)
{
		return static_cast<QTabWidget*>(ptr)->indexOf(static_cast<QWidget*>(w));
}

void QTabWidget_InitStyleOption(void* ptr, void* option)
{
	static_cast<QTabWidget*>(ptr)->initStyleOption(static_cast<QStyleOptionTabWidgetFrame*>(option));
}

int QTabWidget_InsertTab(void* ptr, int index, void* page, struct QtWidgets_PackedString label)
{
		return static_cast<QTabWidget*>(ptr)->insertTab(index, static_cast<QWidget*>(page), QString::fromUtf8(label.data, label.len));
}

int QTabWidget_InsertTab2(void* ptr, int index, void* page, void* icon, struct QtWidgets_PackedString label)
{
		return static_cast<QTabWidget*>(ptr)->insertTab(index, static_cast<QWidget*>(page), *static_cast<QIcon*>(icon), QString::fromUtf8(label.data, label.len));
}

char QTabWidget_IsMovable(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->isMovable();
}

char QTabWidget_IsTabEnabled(void* ptr, int index)
{
	return static_cast<QTabWidget*>(ptr)->isTabEnabled(index);
}

void QTabWidget_RemoveTab(void* ptr, int index)
{
	static_cast<QTabWidget*>(ptr)->removeTab(index);
}

void QTabWidget_SetCornerWidget(void* ptr, void* widget, long long corner)
{
		static_cast<QTabWidget*>(ptr)->setCornerWidget(static_cast<QWidget*>(widget), static_cast<Qt::Corner>(corner));
}

void QTabWidget_SetCurrentIndex(void* ptr, int index)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setCurrentIndex", Q_ARG(int, index));
}

void QTabWidget_SetCurrentIndexDefault(void* ptr, int index)
{
		static_cast<QTabWidget*>(ptr)->QTabWidget::setCurrentIndex(index);
}

void QTabWidget_SetCurrentWidget(void* ptr, void* widget)
{
		QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setCurrentWidget", Q_ARG(QWidget*, static_cast<QWidget*>(widget)));
}

void QTabWidget_SetCurrentWidgetDefault(void* ptr, void* widget)
{
		static_cast<QTabWidget*>(ptr)->QTabWidget::setCurrentWidget(static_cast<QWidget*>(widget));
}

void QTabWidget_SetDocumentMode(void* ptr, char set)
{
	static_cast<QTabWidget*>(ptr)->setDocumentMode(set != 0);
}

void QTabWidget_SetElideMode(void* ptr, long long vqt)
{
	static_cast<QTabWidget*>(ptr)->setElideMode(static_cast<Qt::TextElideMode>(vqt));
}

void QTabWidget_SetIconSize(void* ptr, void* size)
{
	static_cast<QTabWidget*>(ptr)->setIconSize(*static_cast<QSize*>(size));
}

void QTabWidget_SetMovable(void* ptr, char movable)
{
	static_cast<QTabWidget*>(ptr)->setMovable(movable != 0);
}

void QTabWidget_SetTabBar(void* ptr, void* tb)
{
	static_cast<QTabWidget*>(ptr)->setTabBar(static_cast<QTabBar*>(tb));
}

void QTabWidget_SetTabBarAutoHide(void* ptr, char enabled)
{
	static_cast<QTabWidget*>(ptr)->setTabBarAutoHide(enabled != 0);
}

void QTabWidget_SetTabEnabled(void* ptr, int index, char enable)
{
	static_cast<QTabWidget*>(ptr)->setTabEnabled(index, enable != 0);
}

void QTabWidget_SetTabIcon(void* ptr, int index, void* icon)
{
	static_cast<QTabWidget*>(ptr)->setTabIcon(index, *static_cast<QIcon*>(icon));
}

void QTabWidget_SetTabPosition(void* ptr, long long vqt)
{
	static_cast<QTabWidget*>(ptr)->setTabPosition(static_cast<QTabWidget::TabPosition>(vqt));
}

void QTabWidget_SetTabShape(void* ptr, long long s)
{
	static_cast<QTabWidget*>(ptr)->setTabShape(static_cast<QTabWidget::TabShape>(s));
}

void QTabWidget_SetTabText(void* ptr, int index, struct QtWidgets_PackedString label)
{
	static_cast<QTabWidget*>(ptr)->setTabText(index, QString::fromUtf8(label.data, label.len));
}

void QTabWidget_SetTabToolTip(void* ptr, int index, struct QtWidgets_PackedString tip)
{
	static_cast<QTabWidget*>(ptr)->setTabToolTip(index, QString::fromUtf8(tip.data, tip.len));
}

void QTabWidget_SetTabWhatsThis(void* ptr, int index, struct QtWidgets_PackedString text)
{
	static_cast<QTabWidget*>(ptr)->setTabWhatsThis(index, QString::fromUtf8(text.data, text.len));
}

void QTabWidget_SetTabsClosable(void* ptr, char closeable)
{
	static_cast<QTabWidget*>(ptr)->setTabsClosable(closeable != 0);
}

void QTabWidget_SetUsesScrollButtons(void* ptr, char useButtons)
{
	static_cast<QTabWidget*>(ptr)->setUsesScrollButtons(useButtons != 0);
}

void* QTabWidget_TabBar(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->tabBar();
}

char QTabWidget_TabBarAutoHide(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->tabBarAutoHide();
}

void QTabWidget_ConnectTabBarClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QTabWidget*>(ptr), static_cast<void (QTabWidget::*)(int)>(&QTabWidget::tabBarClicked), static_cast<MyQTabWidget*>(ptr), static_cast<void (MyQTabWidget::*)(int)>(&MyQTabWidget::Signal_TabBarClicked), static_cast<Qt::ConnectionType>(t));
}

void QTabWidget_DisconnectTabBarClicked(void* ptr)
{
	QObject::disconnect(static_cast<QTabWidget*>(ptr), static_cast<void (QTabWidget::*)(int)>(&QTabWidget::tabBarClicked), static_cast<MyQTabWidget*>(ptr), static_cast<void (MyQTabWidget::*)(int)>(&MyQTabWidget::Signal_TabBarClicked));
}

void QTabWidget_TabBarClicked(void* ptr, int index)
{
	static_cast<QTabWidget*>(ptr)->tabBarClicked(index);
}

void QTabWidget_ConnectTabBarDoubleClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QTabWidget*>(ptr), static_cast<void (QTabWidget::*)(int)>(&QTabWidget::tabBarDoubleClicked), static_cast<MyQTabWidget*>(ptr), static_cast<void (MyQTabWidget::*)(int)>(&MyQTabWidget::Signal_TabBarDoubleClicked), static_cast<Qt::ConnectionType>(t));
}

void QTabWidget_DisconnectTabBarDoubleClicked(void* ptr)
{
	QObject::disconnect(static_cast<QTabWidget*>(ptr), static_cast<void (QTabWidget::*)(int)>(&QTabWidget::tabBarDoubleClicked), static_cast<MyQTabWidget*>(ptr), static_cast<void (MyQTabWidget::*)(int)>(&MyQTabWidget::Signal_TabBarDoubleClicked));
}

void QTabWidget_TabBarDoubleClicked(void* ptr, int index)
{
	static_cast<QTabWidget*>(ptr)->tabBarDoubleClicked(index);
}

void QTabWidget_ConnectTabCloseRequested(void* ptr, long long t)
{
	QObject::connect(static_cast<QTabWidget*>(ptr), static_cast<void (QTabWidget::*)(int)>(&QTabWidget::tabCloseRequested), static_cast<MyQTabWidget*>(ptr), static_cast<void (MyQTabWidget::*)(int)>(&MyQTabWidget::Signal_TabCloseRequested), static_cast<Qt::ConnectionType>(t));
}

void QTabWidget_DisconnectTabCloseRequested(void* ptr)
{
	QObject::disconnect(static_cast<QTabWidget*>(ptr), static_cast<void (QTabWidget::*)(int)>(&QTabWidget::tabCloseRequested), static_cast<MyQTabWidget*>(ptr), static_cast<void (MyQTabWidget::*)(int)>(&MyQTabWidget::Signal_TabCloseRequested));
}

void QTabWidget_TabCloseRequested(void* ptr, int index)
{
	static_cast<QTabWidget*>(ptr)->tabCloseRequested(index);
}

void* QTabWidget_TabIcon(void* ptr, int index)
{
	return new QIcon(static_cast<QTabWidget*>(ptr)->tabIcon(index));
}

void QTabWidget_TabInserted(void* ptr, int index)
{
	static_cast<QTabWidget*>(ptr)->tabInserted(index);
}

void QTabWidget_TabInsertedDefault(void* ptr, int index)
{
		static_cast<QTabWidget*>(ptr)->QTabWidget::tabInserted(index);
}

long long QTabWidget_TabPosition(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->tabPosition();
}

void QTabWidget_TabRemoved(void* ptr, int index)
{
	static_cast<QTabWidget*>(ptr)->tabRemoved(index);
}

void QTabWidget_TabRemovedDefault(void* ptr, int index)
{
		static_cast<QTabWidget*>(ptr)->QTabWidget::tabRemoved(index);
}

long long QTabWidget_TabShape(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->tabShape();
}

struct QtWidgets_PackedString QTabWidget_TabText(void* ptr, int index)
{
	return ({ QByteArray* t5dcd8a = new QByteArray(static_cast<QTabWidget*>(ptr)->tabText(index).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t5dcd8a->prepend("WHITESPACE").constData()+10), t5dcd8a->size()-10, t5dcd8a }; });
}

struct QtWidgets_PackedString QTabWidget_TabToolTip(void* ptr, int index)
{
	return ({ QByteArray* t2994f0 = new QByteArray(static_cast<QTabWidget*>(ptr)->tabToolTip(index).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t2994f0->prepend("WHITESPACE").constData()+10), t2994f0->size()-10, t2994f0 }; });
}

struct QtWidgets_PackedString QTabWidget_TabWhatsThis(void* ptr, int index)
{
	return ({ QByteArray* ta4a3c3 = new QByteArray(static_cast<QTabWidget*>(ptr)->tabWhatsThis(index).toUtf8()); QtWidgets_PackedString { const_cast<char*>(ta4a3c3->prepend("WHITESPACE").constData()+10), ta4a3c3->size()-10, ta4a3c3 }; });
}

char QTabWidget_TabsClosable(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->tabsClosable();
}

char QTabWidget_UsesScrollButtons(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->usesScrollButtons();
}

void* QTabWidget_Widget(void* ptr, int index)
{
	return static_cast<QTabWidget*>(ptr)->widget(index);
}

void QTabWidget_DestroyQTabWidget(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->~QTabWidget();
}

void QTabWidget_DestroyQTabWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQTableView: public QTableView
{
public:
	MyQTableView(QWidget *parent = Q_NULLPTR) : QTableView(parent) {QTableView_QTableView_QRegisterMetaType();};
	void columnCountChanged(int oldCount, int newCount) { callbackQTableView_ColumnCountChanged(this, oldCount, newCount); };
	void columnMoved(int column, int oldIndex, int newIndex) { callbackQTableView_ColumnMoved(this, column, oldIndex, newIndex); };
	void columnResized(int column, int oldWidth, int newWidth) { callbackQTableView_ColumnResized(this, column, oldWidth, newWidth); };
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQTableView_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	void hideColumn(int column) { callbackQTableView_HideColumn(this, column); };
	void hideRow(int row) { callbackQTableView_HideRow(this, row); };
	int horizontalOffset() const { return callbackQTableView_HorizontalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QModelIndex indexAt(const QPoint & pos) const { return *static_cast<QModelIndex*>(callbackQTableView_IndexAt(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&pos))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQTableView_IsIndexHidden(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index)) != 0; };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQTableView_MoveCursor(this, cursorAction, modifiers)); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void resizeColumnToContents(int column) { callbackQTableView_ResizeColumnToContents(this, column); };
	void resizeColumnsToContents() { callbackQTableView_ResizeColumnsToContents(this); };
	void resizeRowToContents(int row) { callbackQTableView_ResizeRowToContents(this, row); };
	void resizeRowsToContents() { callbackQTableView_ResizeRowsToContents(this); };
	void rowCountChanged(int oldCount, int newCount) { callbackQTableView_RowCountChanged(this, oldCount, newCount); };
	void rowMoved(int row, int oldIndex, int newIndex) { callbackQTableView_RowMoved(this, row, oldIndex, newIndex); };
	void rowResized(int row, int oldHeight, int newHeight) { callbackQTableView_RowResized(this, row, oldHeight, newHeight); };
	void selectColumn(int column) { callbackQTableView_SelectColumn(this, column); };
	void selectRow(int row) { callbackQTableView_SelectRow(this, row); };
	QList<QModelIndex> selectedIndexes() const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemView_SelectedIndexes(const_cast<void*>(static_cast<const void*>(this)))); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQTableView_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	void setModel(QAbstractItemModel * model) { callbackQAbstractItemView_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQTableView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags flags) { callbackQTableView_SetSelection(this, const_cast<QRect*>(&rect), flags); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQAbstractItemView_SetSelectionModel(this, selectionModel); };
	void setShowGrid(bool show) { callbackQTableView_SetShowGrid(this, show); };
	void showColumn(int column) { callbackQTableView_ShowColumn(this, column); };
	void showRow(int row) { callbackQTableView_ShowRow(this, row); };
	int sizeHintForColumn(int column) const { return callbackQAbstractItemView_SizeHintForColumn(const_cast<void*>(static_cast<const void*>(this)), column); };
	int sizeHintForRow(int row) const { return callbackQAbstractItemView_SizeHintForRow(const_cast<void*>(static_cast<const void*>(this)), row); };
	void sortByColumn(int column, Qt::SortOrder order) { callbackQTableView_SortByColumn(this, column, order); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	void updateGeometries() { callbackQTableView_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQTableView_VerticalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQAbstractItemView_ViewOptions(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQTableView() { callbackQTableView_DestroyQTableView(this); };
	void Signal_Activated(const QModelIndex & index) { callbackQAbstractItemView_Activated(this, const_cast<QModelIndex*>(&index)); };
	void clearSelection() { callbackQAbstractItemView_ClearSelection(this); };
	void Signal_Clicked(const QModelIndex & index) { callbackQAbstractItemView_Clicked(this, const_cast<QModelIndex*>(&index)); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQAbstractItemView_CommitData(this, editor); };
	void dataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemView_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
	void Signal_DoubleClicked(const QModelIndex & index) { callbackQAbstractItemView_DoubleClicked(this, const_cast<QModelIndex*>(&index)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQAbstractItemView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQAbstractItemView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQAbstractItemView_EditorDestroyed(this, editor); };
	void Signal_Entered(const QModelIndex & index) { callbackQAbstractItemView_Entered(this, const_cast<QModelIndex*>(&index)); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQWidget_EventFilter(this, object, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void Signal_IconSizeChanged(const QSize & size) { callbackQAbstractItemView_IconSizeChanged(this, const_cast<QSize*>(&size)); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { QByteArray* t3559d7 = new QByteArray(search.toUtf8()); QtWidgets_PackedString searchPacked = { const_cast<char*>(t3559d7->prepend("WHITESPACE").constData()+10), t3559d7->size()-10, t3559d7 };callbackQAbstractItemView_KeyboardSearch(this, searchPacked); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void Signal_Pressed(const QModelIndex & index) { callbackQAbstractItemView_Pressed(this, const_cast<QModelIndex*>(&index)); };
	void reset() { callbackQAbstractItemView_Reset(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQAbstractItemView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemView_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQTableView_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	void scrollToBottom() { callbackQAbstractItemView_ScrollToBottom(this); };
	void scrollToTop() { callbackQAbstractItemView_ScrollToTop(this); };
	void selectAll() { callbackQAbstractItemView_SelectAll(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQAbstractItemView_SelectionCommand(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQAbstractItemView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	void startDrag(Qt::DropActions supportedActions) { callbackQAbstractItemView_StartDrag(this, supportedActions); };
	void update(const QModelIndex & index) { callbackQAbstractItemView_Update(this, const_cast<QModelIndex*>(&index)); };
	void Signal_ViewportEntered() { callbackQAbstractItemView_ViewportEntered(this); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQTableView_VisualRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQTableView_VisualRegionForSelection(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&selection))); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QTableView*)
Q_DECLARE_METATYPE(MyQTableView*)

int QTableView_QTableView_QRegisterMetaType(){qRegisterMetaType<QTableView*>(); return qRegisterMetaType<MyQTableView*>();}

void* QTableView_NewQTableView(void* parent)
{
		return new MyQTableView(static_cast<QWidget*>(parent));
}

void QTableView_ClearSpans(void* ptr)
{
	static_cast<QTableView*>(ptr)->clearSpans();
}

int QTableView_ColumnAt(void* ptr, int x)
{
	return static_cast<QTableView*>(ptr)->columnAt(x);
}

void QTableView_ColumnCountChanged(void* ptr, int oldCount, int newCount)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "columnCountChanged", Q_ARG(int, oldCount), Q_ARG(int, newCount));
}

void QTableView_ColumnCountChangedDefault(void* ptr, int oldCount, int newCount)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::columnCountChanged(oldCount, newCount);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::columnCountChanged(oldCount, newCount);
	}
}

void QTableView_ColumnMoved(void* ptr, int column, int oldIndex, int newIndex)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "columnMoved", Q_ARG(int, column), Q_ARG(int, oldIndex), Q_ARG(int, newIndex));
}

void QTableView_ColumnMovedDefault(void* ptr, int column, int oldIndex, int newIndex)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::columnMoved(column, oldIndex, newIndex);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::columnMoved(column, oldIndex, newIndex);
	}
}

void QTableView_ColumnResized(void* ptr, int column, int oldWidth, int newWidth)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "columnResized", Q_ARG(int, column), Q_ARG(int, oldWidth), Q_ARG(int, newWidth));
}

void QTableView_ColumnResizedDefault(void* ptr, int column, int oldWidth, int newWidth)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::columnResized(column, oldWidth, newWidth);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::columnResized(column, oldWidth, newWidth);
	}
}

int QTableView_ColumnSpan(void* ptr, int row, int column)
{
	return static_cast<QTableView*>(ptr)->columnSpan(row, column);
}

int QTableView_ColumnViewportPosition(void* ptr, int column)
{
	return static_cast<QTableView*>(ptr)->columnViewportPosition(column);
}

int QTableView_ColumnWidth(void* ptr, int column)
{
	return static_cast<QTableView*>(ptr)->columnWidth(column);
}

void QTableView_CurrentChanged(void* ptr, void* current, void* previous)
{
	static_cast<QTableView*>(ptr)->currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QTableView_CurrentChangedDefault(void* ptr, void* current, void* previous)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	} else {
		static_cast<QTableView*>(ptr)->QTableView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	}
}

long long QTableView_GridStyle(void* ptr)
{
	return static_cast<QTableView*>(ptr)->gridStyle();
}

void QTableView_HideColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "hideColumn", Q_ARG(int, column));
}

void QTableView_HideColumnDefault(void* ptr, int column)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::hideColumn(column);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::hideColumn(column);
	}
}

void QTableView_HideRow(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "hideRow", Q_ARG(int, row));
}

void QTableView_HideRowDefault(void* ptr, int row)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::hideRow(row);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::hideRow(row);
	}
}

void* QTableView_HorizontalHeader(void* ptr)
{
	return static_cast<QTableView*>(ptr)->horizontalHeader();
}

int QTableView_HorizontalOffset(void* ptr)
{
	return static_cast<QTableView*>(ptr)->horizontalOffset();
}

int QTableView_HorizontalOffsetDefault(void* ptr)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::horizontalOffset();
	} else {
		return static_cast<QTableView*>(ptr)->QTableView::horizontalOffset();
	}
}

void* QTableView_IndexAt(void* ptr, void* pos)
{
	return new QModelIndex(static_cast<QTableView*>(ptr)->indexAt(*static_cast<QPoint*>(pos)));
}

void* QTableView_IndexAtDefault(void* ptr, void* pos)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return new QModelIndex(static_cast<QTableWidget*>(ptr)->QTableWidget::indexAt(*static_cast<QPoint*>(pos)));
	} else {
		return new QModelIndex(static_cast<QTableView*>(ptr)->QTableView::indexAt(*static_cast<QPoint*>(pos)));
	}
}

char QTableView_IsColumnHidden(void* ptr, int column)
{
	return static_cast<QTableView*>(ptr)->isColumnHidden(column);
}

char QTableView_IsCornerButtonEnabled(void* ptr)
{
	return static_cast<QTableView*>(ptr)->isCornerButtonEnabled();
}

char QTableView_IsIndexHidden(void* ptr, void* index)
{
	return static_cast<QTableView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}

char QTableView_IsIndexHiddenDefault(void* ptr, void* index)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::isIndexHidden(*static_cast<QModelIndex*>(index));
	} else {
		return static_cast<QTableView*>(ptr)->QTableView::isIndexHidden(*static_cast<QModelIndex*>(index));
	}
}

char QTableView_IsRowHidden(void* ptr, int row)
{
	return static_cast<QTableView*>(ptr)->isRowHidden(row);
}

char QTableView_IsSortingEnabled(void* ptr)
{
	return static_cast<QTableView*>(ptr)->isSortingEnabled();
}

void* QTableView_MoveCursor(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QTableView*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void* QTableView_MoveCursorDefault(void* ptr, long long cursorAction, long long modifiers)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return new QModelIndex(static_cast<QTableWidget*>(ptr)->QTableWidget::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
	} else {
		return new QModelIndex(static_cast<QTableView*>(ptr)->QTableView::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
	}
}

void QTableView_ResizeColumnToContents(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "resizeColumnToContents", Q_ARG(int, column));
}

void QTableView_ResizeColumnToContentsDefault(void* ptr, int column)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::resizeColumnToContents(column);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::resizeColumnToContents(column);
	}
}

void QTableView_ResizeColumnsToContents(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "resizeColumnsToContents");
}

void QTableView_ResizeColumnsToContentsDefault(void* ptr)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::resizeColumnsToContents();
	} else {
		static_cast<QTableView*>(ptr)->QTableView::resizeColumnsToContents();
	}
}

void QTableView_ResizeRowToContents(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "resizeRowToContents", Q_ARG(int, row));
}

void QTableView_ResizeRowToContentsDefault(void* ptr, int row)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::resizeRowToContents(row);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::resizeRowToContents(row);
	}
}

void QTableView_ResizeRowsToContents(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "resizeRowsToContents");
}

void QTableView_ResizeRowsToContentsDefault(void* ptr)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::resizeRowsToContents();
	} else {
		static_cast<QTableView*>(ptr)->QTableView::resizeRowsToContents();
	}
}

int QTableView_RowAt(void* ptr, int y)
{
	return static_cast<QTableView*>(ptr)->rowAt(y);
}

void QTableView_RowCountChanged(void* ptr, int oldCount, int newCount)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "rowCountChanged", Q_ARG(int, oldCount), Q_ARG(int, newCount));
}

void QTableView_RowCountChangedDefault(void* ptr, int oldCount, int newCount)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::rowCountChanged(oldCount, newCount);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::rowCountChanged(oldCount, newCount);
	}
}

int QTableView_RowHeight(void* ptr, int row)
{
	return static_cast<QTableView*>(ptr)->rowHeight(row);
}

void QTableView_RowMoved(void* ptr, int row, int oldIndex, int newIndex)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "rowMoved", Q_ARG(int, row), Q_ARG(int, oldIndex), Q_ARG(int, newIndex));
}

void QTableView_RowMovedDefault(void* ptr, int row, int oldIndex, int newIndex)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::rowMoved(row, oldIndex, newIndex);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::rowMoved(row, oldIndex, newIndex);
	}
}

void QTableView_RowResized(void* ptr, int row, int oldHeight, int newHeight)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "rowResized", Q_ARG(int, row), Q_ARG(int, oldHeight), Q_ARG(int, newHeight));
}

void QTableView_RowResizedDefault(void* ptr, int row, int oldHeight, int newHeight)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::rowResized(row, oldHeight, newHeight);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::rowResized(row, oldHeight, newHeight);
	}
}

int QTableView_RowSpan(void* ptr, int row, int column)
{
	return static_cast<QTableView*>(ptr)->rowSpan(row, column);
}

int QTableView_RowViewportPosition(void* ptr, int row)
{
	return static_cast<QTableView*>(ptr)->rowViewportPosition(row);
}

void QTableView_SelectColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "selectColumn", Q_ARG(int, column));
}

void QTableView_SelectColumnDefault(void* ptr, int column)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::selectColumn(column);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::selectColumn(column);
	}
}

void QTableView_SelectRow(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "selectRow", Q_ARG(int, row));
}

void QTableView_SelectRowDefault(void* ptr, int row)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::selectRow(row);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::selectRow(row);
	}
}

void QTableView_SelectionChanged(void* ptr, void* selected, void* deselected)
{
	static_cast<QTableView*>(ptr)->selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

void QTableView_SelectionChangedDefault(void* ptr, void* selected, void* deselected)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	} else {
		static_cast<QTableView*>(ptr)->QTableView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	}
}

void QTableView_SetColumnHidden(void* ptr, int column, char hide)
{
	static_cast<QTableView*>(ptr)->setColumnHidden(column, hide != 0);
}

void QTableView_SetColumnWidth(void* ptr, int column, int width)
{
	static_cast<QTableView*>(ptr)->setColumnWidth(column, width);
}

void QTableView_SetCornerButtonEnabled(void* ptr, char enable)
{
	static_cast<QTableView*>(ptr)->setCornerButtonEnabled(enable != 0);
}

void QTableView_SetGridStyle(void* ptr, long long style)
{
	static_cast<QTableView*>(ptr)->setGridStyle(static_cast<Qt::PenStyle>(style));
}

void QTableView_SetHorizontalHeader(void* ptr, void* header)
{
	static_cast<QTableView*>(ptr)->setHorizontalHeader(static_cast<QHeaderView*>(header));
}

void QTableView_SetRootIndex(void* ptr, void* index)
{
	static_cast<QTableView*>(ptr)->setRootIndex(*static_cast<QModelIndex*>(index));
}

void QTableView_SetRootIndexDefault(void* ptr, void* index)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setRootIndex(*static_cast<QModelIndex*>(index));
	} else {
		static_cast<QTableView*>(ptr)->QTableView::setRootIndex(*static_cast<QModelIndex*>(index));
	}
}

void QTableView_SetRowHeight(void* ptr, int row, int height)
{
	static_cast<QTableView*>(ptr)->setRowHeight(row, height);
}

void QTableView_SetRowHidden(void* ptr, int row, char hide)
{
	static_cast<QTableView*>(ptr)->setRowHidden(row, hide != 0);
}

void QTableView_SetSelection(void* ptr, void* rect, long long flags)
{
	static_cast<QTableView*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
}

void QTableView_SetSelectionDefault(void* ptr, void* rect, long long flags)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
	} else {
		static_cast<QTableView*>(ptr)->QTableView::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
	}
}

void QTableView_SetShowGrid(void* ptr, char show)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setShowGrid", Q_ARG(bool, show != 0));
}

void QTableView_SetShowGridDefault(void* ptr, char show)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setShowGrid(show != 0);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::setShowGrid(show != 0);
	}
}

void QTableView_SetSortingEnabled(void* ptr, char enable)
{
	static_cast<QTableView*>(ptr)->setSortingEnabled(enable != 0);
}

void QTableView_SetSpan(void* ptr, int row, int column, int rowSpanCount, int columnSpanCount)
{
	static_cast<QTableView*>(ptr)->setSpan(row, column, rowSpanCount, columnSpanCount);
}

void QTableView_SetVerticalHeader(void* ptr, void* header)
{
	static_cast<QTableView*>(ptr)->setVerticalHeader(static_cast<QHeaderView*>(header));
}

void QTableView_SetWordWrap(void* ptr, char on)
{
	static_cast<QTableView*>(ptr)->setWordWrap(on != 0);
}

void QTableView_ShowColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "showColumn", Q_ARG(int, column));
}

void QTableView_ShowColumnDefault(void* ptr, int column)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::showColumn(column);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::showColumn(column);
	}
}

char QTableView_ShowGrid(void* ptr)
{
	return static_cast<QTableView*>(ptr)->showGrid();
}

void QTableView_ShowRow(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "showRow", Q_ARG(int, row));
}

void QTableView_ShowRowDefault(void* ptr, int row)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::showRow(row);
	} else {
		static_cast<QTableView*>(ptr)->QTableView::showRow(row);
	}
}

void QTableView_SortByColumn(void* ptr, int column, long long order)
{
	qRegisterMetaType<Qt::SortOrder>();
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "sortByColumn", Q_ARG(int, column), Q_ARG(Qt::SortOrder, static_cast<Qt::SortOrder>(order)));
}

void QTableView_SortByColumnDefault(void* ptr, int column, long long order)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::sortByColumn(column, static_cast<Qt::SortOrder>(order));
	} else {
		static_cast<QTableView*>(ptr)->QTableView::sortByColumn(column, static_cast<Qt::SortOrder>(order));
	}
}

void QTableView_UpdateGeometries(void* ptr)
{
	static_cast<QTableView*>(ptr)->updateGeometries();
}

void QTableView_UpdateGeometriesDefault(void* ptr)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::updateGeometries();
	} else {
		static_cast<QTableView*>(ptr)->QTableView::updateGeometries();
	}
}

void* QTableView_VerticalHeader(void* ptr)
{
	return static_cast<QTableView*>(ptr)->verticalHeader();
}

int QTableView_VerticalOffset(void* ptr)
{
	return static_cast<QTableView*>(ptr)->verticalOffset();
}

int QTableView_VerticalOffsetDefault(void* ptr)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::verticalOffset();
	} else {
		return static_cast<QTableView*>(ptr)->QTableView::verticalOffset();
	}
}

char QTableView_WordWrap(void* ptr)
{
	return static_cast<QTableView*>(ptr)->wordWrap();
}

void QTableView_DestroyQTableView(void* ptr)
{
	static_cast<QTableView*>(ptr)->~QTableView();
}

void QTableView_DestroyQTableViewDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void QTableView_ScrollTo(void* ptr, void* index, long long hint)
{
	static_cast<QTableView*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QTableView_ScrollToDefault(void* ptr, void* index, long long hint)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
	} else {
		static_cast<QTableView*>(ptr)->QTableView::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
	}
}

void* QTableView_VisualRect(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QTableView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QTableView_VisualRectDefault(void* ptr, void* index)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QTableWidget*>(ptr)->QTableWidget::visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRect tmpValue = static_cast<QTableView*>(ptr)->QTableView::visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QTableView_VisualRegionForSelection(void* ptr, void* selection)
{
	return new QRegion(static_cast<QTableView*>(ptr)->visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void* QTableView_VisualRegionForSelectionDefault(void* ptr, void* selection)
{
	if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return new QRegion(static_cast<QTableWidget*>(ptr)->QTableWidget::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
	} else {
		return new QRegion(static_cast<QTableView*>(ptr)->QTableView::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
	}
}

class MyQTableWidget: public QTableWidget
{
public:
	MyQTableWidget(QWidget *parent = Q_NULLPTR) : QTableWidget(parent) {QTableWidget_QTableWidget_QRegisterMetaType();};
	MyQTableWidget(int rows, int columns, QWidget *parent = Q_NULLPTR) : QTableWidget(rows, columns, parent) {QTableWidget_QTableWidget_QRegisterMetaType();};
	void Signal_CellActivated(int row, int column) { callbackQTableWidget_CellActivated(this, row, column); };
	void Signal_CellChanged(int row, int column) { callbackQTableWidget_CellChanged(this, row, column); };
	void Signal_CellClicked(int row, int column) { callbackQTableWidget_CellClicked(this, row, column); };
	void Signal_CellDoubleClicked(int row, int column) { callbackQTableWidget_CellDoubleClicked(this, row, column); };
	void Signal_CellEntered(int row, int column) { callbackQTableWidget_CellEntered(this, row, column); };
	void Signal_CellPressed(int row, int column) { callbackQTableWidget_CellPressed(this, row, column); };
	void clear() { callbackQTableWidget_Clear(this); };
	void clearContents() { callbackQTableWidget_ClearContents(this); };
	void Signal_CurrentCellChanged(int currentRow, int currentColumn, int previousRow, int previousColumn) { callbackQTableWidget_CurrentCellChanged(this, currentRow, currentColumn, previousRow, previousColumn); };
	void Signal_CurrentItemChanged(QTableWidgetItem * current, QTableWidgetItem * previous) { callbackQTableWidget_CurrentItemChanged(this, current, previous); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	bool dropMimeData(int row, int column, const QMimeData * data, Qt::DropAction action) { return callbackQTableWidget_DropMimeData(this, row, column, const_cast<QMimeData*>(data), action) != 0; };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void insertColumn(int column) { callbackQTableWidget_InsertColumn(this, column); };
	void insertRow(int row) { callbackQTableWidget_InsertRow(this, row); };
	void Signal_ItemActivated(QTableWidgetItem * item) { callbackQTableWidget_ItemActivated(this, item); };
	void Signal_ItemChanged(QTableWidgetItem * item) { callbackQTableWidget_ItemChanged(this, item); };
	void Signal_ItemClicked(QTableWidgetItem * item) { callbackQTableWidget_ItemClicked(this, item); };
	void Signal_ItemDoubleClicked(QTableWidgetItem * item) { callbackQTableWidget_ItemDoubleClicked(this, item); };
	void Signal_ItemEntered(QTableWidgetItem * item) { callbackQTableWidget_ItemEntered(this, item); };
	void Signal_ItemPressed(QTableWidgetItem * item) { callbackQTableWidget_ItemPressed(this, item); };
	void Signal_ItemSelectionChanged() { callbackQTableWidget_ItemSelectionChanged(this); };
	QMimeData * mimeData(const QList<QTableWidgetItem *> items) const { return static_cast<QMimeData*>(callbackQTableWidget_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QTableWidgetItem *>* tmpValue7316c8 = new QList<QTableWidgetItem *>(items); QtWidgets_PackedList { tmpValue7316c8, tmpValue7316c8->size() }; }))); };
	QStringList mimeTypes() const { return ({ QtWidgets_PackedString tempVal = callbackQTableWidget_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	void removeColumn(int column) { callbackQTableWidget_RemoveColumn(this, column); };
	void removeRow(int row) { callbackQTableWidget_RemoveRow(this, row); };
	void scrollToItem(const QTableWidgetItem * item, QAbstractItemView::ScrollHint hint) { callbackQTableWidget_ScrollToItem(this, const_cast<QTableWidgetItem*>(item), hint); };
	Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQTableWidget_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQTableWidget() { callbackQTableWidget_DestroyQTableWidget(this); };
	void columnCountChanged(int oldCount, int newCount) { callbackQTableView_ColumnCountChanged(this, oldCount, newCount); };
	void columnMoved(int column, int oldIndex, int newIndex) { callbackQTableView_ColumnMoved(this, column, oldIndex, newIndex); };
	void columnResized(int column, int oldWidth, int newWidth) { callbackQTableView_ColumnResized(this, column, oldWidth, newWidth); };
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQTableView_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	void hideColumn(int column) { callbackQTableView_HideColumn(this, column); };
	void hideRow(int row) { callbackQTableView_HideRow(this, row); };
	int horizontalOffset() const { return callbackQTableView_HorizontalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QModelIndex indexAt(const QPoint & pos) const { return *static_cast<QModelIndex*>(callbackQTableView_IndexAt(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&pos))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQTableView_IsIndexHidden(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index)) != 0; };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQTableView_MoveCursor(this, cursorAction, modifiers)); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void resizeColumnToContents(int column) { callbackQTableView_ResizeColumnToContents(this, column); };
	void resizeColumnsToContents() { callbackQTableView_ResizeColumnsToContents(this); };
	void resizeRowToContents(int row) { callbackQTableView_ResizeRowToContents(this, row); };
	void resizeRowsToContents() { callbackQTableView_ResizeRowsToContents(this); };
	void rowCountChanged(int oldCount, int newCount) { callbackQTableView_RowCountChanged(this, oldCount, newCount); };
	void rowMoved(int row, int oldIndex, int newIndex) { callbackQTableView_RowMoved(this, row, oldIndex, newIndex); };
	void rowResized(int row, int oldHeight, int newHeight) { callbackQTableView_RowResized(this, row, oldHeight, newHeight); };
	void selectColumn(int column) { callbackQTableView_SelectColumn(this, column); };
	void selectRow(int row) { callbackQTableView_SelectRow(this, row); };
	QList<QModelIndex> selectedIndexes() const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemView_SelectedIndexes(const_cast<void*>(static_cast<const void*>(this)))); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQTableView_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	void setModel(QAbstractItemModel * model) { callbackQAbstractItemView_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQTableView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags flags) { callbackQTableView_SetSelection(this, const_cast<QRect*>(&rect), flags); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQAbstractItemView_SetSelectionModel(this, selectionModel); };
	void setShowGrid(bool show) { callbackQTableView_SetShowGrid(this, show); };
	void showColumn(int column) { callbackQTableView_ShowColumn(this, column); };
	void showRow(int row) { callbackQTableView_ShowRow(this, row); };
	int sizeHintForColumn(int column) const { return callbackQAbstractItemView_SizeHintForColumn(const_cast<void*>(static_cast<const void*>(this)), column); };
	int sizeHintForRow(int row) const { return callbackQAbstractItemView_SizeHintForRow(const_cast<void*>(static_cast<const void*>(this)), row); };
	void sortByColumn(int column, Qt::SortOrder order) { callbackQTableView_SortByColumn(this, column, order); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	void updateGeometries() { callbackQTableView_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQTableView_VerticalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQAbstractItemView_ViewOptions(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_Activated(const QModelIndex & index) { callbackQAbstractItemView_Activated(this, const_cast<QModelIndex*>(&index)); };
	void clearSelection() { callbackQAbstractItemView_ClearSelection(this); };
	void Signal_Clicked(const QModelIndex & index) { callbackQAbstractItemView_Clicked(this, const_cast<QModelIndex*>(&index)); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQAbstractItemView_CommitData(this, editor); };
	void dataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemView_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
	void Signal_DoubleClicked(const QModelIndex & index) { callbackQAbstractItemView_DoubleClicked(this, const_cast<QModelIndex*>(&index)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQAbstractItemView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQAbstractItemView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQAbstractItemView_EditorDestroyed(this, editor); };
	void Signal_Entered(const QModelIndex & index) { callbackQAbstractItemView_Entered(this, const_cast<QModelIndex*>(&index)); };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQWidget_EventFilter(this, object, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void Signal_IconSizeChanged(const QSize & size) { callbackQAbstractItemView_IconSizeChanged(this, const_cast<QSize*>(&size)); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { QByteArray* t3559d7 = new QByteArray(search.toUtf8()); QtWidgets_PackedString searchPacked = { const_cast<char*>(t3559d7->prepend("WHITESPACE").constData()+10), t3559d7->size()-10, t3559d7 };callbackQAbstractItemView_KeyboardSearch(this, searchPacked); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void Signal_Pressed(const QModelIndex & index) { callbackQAbstractItemView_Pressed(this, const_cast<QModelIndex*>(&index)); };
	void reset() { callbackQAbstractItemView_Reset(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQAbstractItemView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemView_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQTableView_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	void scrollToBottom() { callbackQAbstractItemView_ScrollToBottom(this); };
	void scrollToTop() { callbackQAbstractItemView_ScrollToTop(this); };
	void selectAll() { callbackQAbstractItemView_SelectAll(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQAbstractItemView_SelectionCommand(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQAbstractItemView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	void startDrag(Qt::DropActions supportedActions) { callbackQAbstractItemView_StartDrag(this, supportedActions); };
	void update(const QModelIndex & index) { callbackQAbstractItemView_Update(this, const_cast<QModelIndex*>(&index)); };
	void Signal_ViewportEntered() { callbackQAbstractItemView_ViewportEntered(this); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQTableView_VisualRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQTableView_VisualRegionForSelection(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&selection))); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QTableWidget*)
Q_DECLARE_METATYPE(MyQTableWidget*)

int QTableWidget_QTableWidget_QRegisterMetaType(){qRegisterMetaType<QTableWidget*>(); return qRegisterMetaType<MyQTableWidget*>();}

void* QTableWidget_NewQTableWidget(void* parent)
{
		return new MyQTableWidget(static_cast<QWidget*>(parent));
}

void* QTableWidget_NewQTableWidget2(int rows, int columns, void* parent)
{
		return new MyQTableWidget(rows, columns, static_cast<QWidget*>(parent));
}

void QTableWidget_ConnectCellActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int)>(&QTableWidget::cellActivated), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int)>(&MyQTableWidget::Signal_CellActivated), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectCellActivated(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int)>(&QTableWidget::cellActivated), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int)>(&MyQTableWidget::Signal_CellActivated));
}

void QTableWidget_CellActivated(void* ptr, int row, int column)
{
	static_cast<QTableWidget*>(ptr)->cellActivated(row, column);
}

void QTableWidget_ConnectCellChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int)>(&QTableWidget::cellChanged), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int)>(&MyQTableWidget::Signal_CellChanged), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectCellChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int)>(&QTableWidget::cellChanged), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int)>(&MyQTableWidget::Signal_CellChanged));
}

void QTableWidget_CellChanged(void* ptr, int row, int column)
{
	static_cast<QTableWidget*>(ptr)->cellChanged(row, column);
}

void QTableWidget_ConnectCellClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int)>(&QTableWidget::cellClicked), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int)>(&MyQTableWidget::Signal_CellClicked), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectCellClicked(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int)>(&QTableWidget::cellClicked), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int)>(&MyQTableWidget::Signal_CellClicked));
}

void QTableWidget_CellClicked(void* ptr, int row, int column)
{
	static_cast<QTableWidget*>(ptr)->cellClicked(row, column);
}

void QTableWidget_ConnectCellDoubleClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int)>(&QTableWidget::cellDoubleClicked), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int)>(&MyQTableWidget::Signal_CellDoubleClicked), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectCellDoubleClicked(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int)>(&QTableWidget::cellDoubleClicked), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int)>(&MyQTableWidget::Signal_CellDoubleClicked));
}

void QTableWidget_CellDoubleClicked(void* ptr, int row, int column)
{
	static_cast<QTableWidget*>(ptr)->cellDoubleClicked(row, column);
}

void QTableWidget_ConnectCellEntered(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int)>(&QTableWidget::cellEntered), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int)>(&MyQTableWidget::Signal_CellEntered), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectCellEntered(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int)>(&QTableWidget::cellEntered), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int)>(&MyQTableWidget::Signal_CellEntered));
}

void QTableWidget_CellEntered(void* ptr, int row, int column)
{
	static_cast<QTableWidget*>(ptr)->cellEntered(row, column);
}

void QTableWidget_ConnectCellPressed(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int)>(&QTableWidget::cellPressed), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int)>(&MyQTableWidget::Signal_CellPressed), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectCellPressed(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int)>(&QTableWidget::cellPressed), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int)>(&MyQTableWidget::Signal_CellPressed));
}

void QTableWidget_CellPressed(void* ptr, int row, int column)
{
	static_cast<QTableWidget*>(ptr)->cellPressed(row, column);
}

void* QTableWidget_CellWidget(void* ptr, int row, int column)
{
	return static_cast<QTableWidget*>(ptr)->cellWidget(row, column);
}

void QTableWidget_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "clear");
}

void QTableWidget_ClearDefault(void* ptr)
{
		static_cast<QTableWidget*>(ptr)->QTableWidget::clear();
}

void QTableWidget_ClearContents(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "clearContents");
}

void QTableWidget_ClearContentsDefault(void* ptr)
{
		static_cast<QTableWidget*>(ptr)->QTableWidget::clearContents();
}

void QTableWidget_ClosePersistentEditor(void* ptr, void* item)
{
	static_cast<QTableWidget*>(ptr)->closePersistentEditor(static_cast<QTableWidgetItem*>(item));
}

int QTableWidget_Column(void* ptr, void* item)
{
	return static_cast<QTableWidget*>(ptr)->column(static_cast<QTableWidgetItem*>(item));
}

int QTableWidget_ColumnCount(void* ptr)
{
	return static_cast<QTableWidget*>(ptr)->columnCount();
}

void QTableWidget_ConnectCurrentCellChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int, int, int)>(&QTableWidget::currentCellChanged), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int, int, int)>(&MyQTableWidget::Signal_CurrentCellChanged), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectCurrentCellChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(int, int, int, int)>(&QTableWidget::currentCellChanged), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(int, int, int, int)>(&MyQTableWidget::Signal_CurrentCellChanged));
}

void QTableWidget_CurrentCellChanged(void* ptr, int currentRow, int currentColumn, int previousRow, int previousColumn)
{
	static_cast<QTableWidget*>(ptr)->currentCellChanged(currentRow, currentColumn, previousRow, previousColumn);
}

int QTableWidget_CurrentColumn(void* ptr)
{
	return static_cast<QTableWidget*>(ptr)->currentColumn();
}

void* QTableWidget_CurrentItem(void* ptr)
{
	return static_cast<QTableWidget*>(ptr)->currentItem();
}

void QTableWidget_ConnectCurrentItemChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *, QTableWidgetItem *)>(&QTableWidget::currentItemChanged), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *, QTableWidgetItem *)>(&MyQTableWidget::Signal_CurrentItemChanged), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectCurrentItemChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *, QTableWidgetItem *)>(&QTableWidget::currentItemChanged), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *, QTableWidgetItem *)>(&MyQTableWidget::Signal_CurrentItemChanged));
}

void QTableWidget_CurrentItemChanged(void* ptr, void* current, void* previous)
{
	static_cast<QTableWidget*>(ptr)->currentItemChanged(static_cast<QTableWidgetItem*>(current), static_cast<QTableWidgetItem*>(previous));
}

int QTableWidget_CurrentRow(void* ptr)
{
	return static_cast<QTableWidget*>(ptr)->currentRow();
}

char QTableWidget_DropMimeData(void* ptr, int row, int column, void* data, long long action)
{
	return static_cast<QTableWidget*>(ptr)->dropMimeData(row, column, static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action));
}

char QTableWidget_DropMimeDataDefault(void* ptr, int row, int column, void* data, long long action)
{
		return static_cast<QTableWidget*>(ptr)->QTableWidget::dropMimeData(row, column, static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action));
}

void QTableWidget_EditItem(void* ptr, void* item)
{
	static_cast<QTableWidget*>(ptr)->editItem(static_cast<QTableWidgetItem*>(item));
}

struct QtWidgets_PackedList QTableWidget_FindItems(void* ptr, struct QtWidgets_PackedString text, long long flags)
{
	return ({ QList<QTableWidgetItem *>* tmpValue51a284 = new QList<QTableWidgetItem *>(static_cast<QTableWidget*>(ptr)->findItems(QString::fromUtf8(text.data, text.len), static_cast<Qt::MatchFlag>(flags))); QtWidgets_PackedList { tmpValue51a284, tmpValue51a284->size() }; });
}

void* QTableWidget_HorizontalHeaderItem(void* ptr, int column)
{
	return static_cast<QTableWidget*>(ptr)->horizontalHeaderItem(column);
}

void* QTableWidget_IndexFromItem(void* ptr, void* item)
{
	return new QModelIndex(static_cast<QTableWidget*>(ptr)->indexFromItem(static_cast<QTableWidgetItem*>(item)));
}

void QTableWidget_InsertColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "insertColumn", Q_ARG(int, column));
}

void QTableWidget_InsertColumnDefault(void* ptr, int column)
{
		static_cast<QTableWidget*>(ptr)->QTableWidget::insertColumn(column);
}

void QTableWidget_InsertRow(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "insertRow", Q_ARG(int, row));
}

void QTableWidget_InsertRowDefault(void* ptr, int row)
{
		static_cast<QTableWidget*>(ptr)->QTableWidget::insertRow(row);
}

char QTableWidget_IsPersistentEditorOpen(void* ptr, void* item)
{
	return static_cast<QTableWidget*>(ptr)->isPersistentEditorOpen(static_cast<QTableWidgetItem*>(item));
}

void* QTableWidget_Item(void* ptr, int row, int column)
{
	return static_cast<QTableWidget*>(ptr)->item(row, column);
}

void QTableWidget_ConnectItemActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *)>(&QTableWidget::itemActivated), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *)>(&MyQTableWidget::Signal_ItemActivated), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectItemActivated(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *)>(&QTableWidget::itemActivated), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *)>(&MyQTableWidget::Signal_ItemActivated));
}

void QTableWidget_ItemActivated(void* ptr, void* item)
{
	static_cast<QTableWidget*>(ptr)->itemActivated(static_cast<QTableWidgetItem*>(item));
}

void* QTableWidget_ItemAt(void* ptr, void* point)
{
	return static_cast<QTableWidget*>(ptr)->itemAt(*static_cast<QPoint*>(point));
}

void* QTableWidget_ItemAt2(void* ptr, int ax, int ay)
{
	return static_cast<QTableWidget*>(ptr)->itemAt(ax, ay);
}

void QTableWidget_ConnectItemChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *)>(&QTableWidget::itemChanged), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *)>(&MyQTableWidget::Signal_ItemChanged), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectItemChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *)>(&QTableWidget::itemChanged), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *)>(&MyQTableWidget::Signal_ItemChanged));
}

void QTableWidget_ItemChanged(void* ptr, void* item)
{
	static_cast<QTableWidget*>(ptr)->itemChanged(static_cast<QTableWidgetItem*>(item));
}

void QTableWidget_ConnectItemClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *)>(&QTableWidget::itemClicked), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *)>(&MyQTableWidget::Signal_ItemClicked), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectItemClicked(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *)>(&QTableWidget::itemClicked), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *)>(&MyQTableWidget::Signal_ItemClicked));
}

void QTableWidget_ItemClicked(void* ptr, void* item)
{
	static_cast<QTableWidget*>(ptr)->itemClicked(static_cast<QTableWidgetItem*>(item));
}

void QTableWidget_ConnectItemDoubleClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *)>(&QTableWidget::itemDoubleClicked), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *)>(&MyQTableWidget::Signal_ItemDoubleClicked), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectItemDoubleClicked(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *)>(&QTableWidget::itemDoubleClicked), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *)>(&MyQTableWidget::Signal_ItemDoubleClicked));
}

void QTableWidget_ItemDoubleClicked(void* ptr, void* item)
{
	static_cast<QTableWidget*>(ptr)->itemDoubleClicked(static_cast<QTableWidgetItem*>(item));
}

void QTableWidget_ConnectItemEntered(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *)>(&QTableWidget::itemEntered), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *)>(&MyQTableWidget::Signal_ItemEntered), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectItemEntered(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *)>(&QTableWidget::itemEntered), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *)>(&MyQTableWidget::Signal_ItemEntered));
}

void QTableWidget_ItemEntered(void* ptr, void* item)
{
	static_cast<QTableWidget*>(ptr)->itemEntered(static_cast<QTableWidgetItem*>(item));
}

void* QTableWidget_ItemFromIndex(void* ptr, void* index)
{
	return static_cast<QTableWidget*>(ptr)->itemFromIndex(*static_cast<QModelIndex*>(index));
}

void QTableWidget_ConnectItemPressed(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *)>(&QTableWidget::itemPressed), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *)>(&MyQTableWidget::Signal_ItemPressed), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectItemPressed(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)(QTableWidgetItem *)>(&QTableWidget::itemPressed), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)(QTableWidgetItem *)>(&MyQTableWidget::Signal_ItemPressed));
}

void QTableWidget_ItemPressed(void* ptr, void* item)
{
	static_cast<QTableWidget*>(ptr)->itemPressed(static_cast<QTableWidgetItem*>(item));
}

void* QTableWidget_ItemPrototype(void* ptr)
{
	return const_cast<QTableWidgetItem*>(static_cast<QTableWidget*>(ptr)->itemPrototype());
}

void QTableWidget_ConnectItemSelectionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)()>(&QTableWidget::itemSelectionChanged), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)()>(&MyQTableWidget::Signal_ItemSelectionChanged), static_cast<Qt::ConnectionType>(t));
}

void QTableWidget_DisconnectItemSelectionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)()>(&QTableWidget::itemSelectionChanged), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)()>(&MyQTableWidget::Signal_ItemSelectionChanged));
}

void QTableWidget_ItemSelectionChanged(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->itemSelectionChanged();
}

struct QtWidgets_PackedList QTableWidget_Items(void* ptr, void* data)
{
	return ({ QList<QTableWidgetItem *>* tmpValueeca21d = new QList<QTableWidgetItem *>(static_cast<QTableWidget*>(ptr)->items(static_cast<QMimeData*>(data))); QtWidgets_PackedList { tmpValueeca21d, tmpValueeca21d->size() }; });
}

void* QTableWidget_MimeData(void* ptr, void* items)
{
	return static_cast<QTableWidget*>(ptr)->mimeData(*static_cast<QList<QTableWidgetItem *>*>(items));
}

void* QTableWidget_MimeDataDefault(void* ptr, void* items)
{
		return static_cast<QTableWidget*>(ptr)->QTableWidget::mimeData(*static_cast<QList<QTableWidgetItem *>*>(items));
}

struct QtWidgets_PackedString QTableWidget_MimeTypes(void* ptr)
{
	return ({ QByteArray* t94a601 = new QByteArray(static_cast<QTableWidget*>(ptr)->mimeTypes().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t94a601->prepend("WHITESPACE").constData()+10), t94a601->size()-10, t94a601 }; });
}

struct QtWidgets_PackedString QTableWidget_MimeTypesDefault(void* ptr)
{
		return ({ QByteArray* t43ec64 = new QByteArray(static_cast<QTableWidget*>(ptr)->QTableWidget::mimeTypes().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t43ec64->prepend("WHITESPACE").constData()+10), t43ec64->size()-10, t43ec64 }; });
}

void QTableWidget_OpenPersistentEditor(void* ptr, void* item)
{
	static_cast<QTableWidget*>(ptr)->openPersistentEditor(static_cast<QTableWidgetItem*>(item));
}

void QTableWidget_RemoveCellWidget(void* ptr, int row, int column)
{
	static_cast<QTableWidget*>(ptr)->removeCellWidget(row, column);
}

void QTableWidget_RemoveColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "removeColumn", Q_ARG(int, column));
}

void QTableWidget_RemoveColumnDefault(void* ptr, int column)
{
		static_cast<QTableWidget*>(ptr)->QTableWidget::removeColumn(column);
}

void QTableWidget_RemoveRow(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "removeRow", Q_ARG(int, row));
}

void QTableWidget_RemoveRowDefault(void* ptr, int row)
{
		static_cast<QTableWidget*>(ptr)->QTableWidget::removeRow(row);
}

int QTableWidget_Row(void* ptr, void* item)
{
	return static_cast<QTableWidget*>(ptr)->row(static_cast<QTableWidgetItem*>(item));
}

int QTableWidget_RowCount(void* ptr)
{
	return static_cast<QTableWidget*>(ptr)->rowCount();
}

void QTableWidget_ScrollToItem(void* ptr, void* item, long long hint)
{
	qRegisterMetaType<QAbstractItemView::ScrollHint>();
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "scrollToItem", Q_ARG(const QTableWidgetItem*, static_cast<QTableWidgetItem*>(item)), Q_ARG(QAbstractItemView::ScrollHint, static_cast<QAbstractItemView::ScrollHint>(hint)));
}

void QTableWidget_ScrollToItemDefault(void* ptr, void* item, long long hint)
{
		static_cast<QTableWidget*>(ptr)->QTableWidget::scrollToItem(static_cast<QTableWidgetItem*>(item), static_cast<QAbstractItemView::ScrollHint>(hint));
}

struct QtWidgets_PackedList QTableWidget_SelectedItems(void* ptr)
{
	return ({ QList<QTableWidgetItem *>* tmpValue1524d7 = new QList<QTableWidgetItem *>(static_cast<QTableWidget*>(ptr)->selectedItems()); QtWidgets_PackedList { tmpValue1524d7, tmpValue1524d7->size() }; });
}

struct QtWidgets_PackedList QTableWidget_SelectedRanges(void* ptr)
{
	return ({ QList<QTableWidgetSelectionRange>* tmpValue3fc18a = new QList<QTableWidgetSelectionRange>(static_cast<QTableWidget*>(ptr)->selectedRanges()); QtWidgets_PackedList { tmpValue3fc18a, tmpValue3fc18a->size() }; });
}

void QTableWidget_SetCellWidget(void* ptr, int row, int column, void* widget)
{
		static_cast<QTableWidget*>(ptr)->setCellWidget(row, column, static_cast<QWidget*>(widget));
}

void QTableWidget_SetColumnCount(void* ptr, int columns)
{
	static_cast<QTableWidget*>(ptr)->setColumnCount(columns);
}

void QTableWidget_SetCurrentCell(void* ptr, int row, int column)
{
	static_cast<QTableWidget*>(ptr)->setCurrentCell(row, column);
}

void QTableWidget_SetCurrentCell2(void* ptr, int row, int column, long long command)
{
	static_cast<QTableWidget*>(ptr)->setCurrentCell(row, column, static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QTableWidget_SetCurrentItem(void* ptr, void* item)
{
	static_cast<QTableWidget*>(ptr)->setCurrentItem(static_cast<QTableWidgetItem*>(item));
}

void QTableWidget_SetCurrentItem2(void* ptr, void* item, long long command)
{
	static_cast<QTableWidget*>(ptr)->setCurrentItem(static_cast<QTableWidgetItem*>(item), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QTableWidget_SetHorizontalHeaderItem(void* ptr, int column, void* item)
{
	static_cast<QTableWidget*>(ptr)->setHorizontalHeaderItem(column, static_cast<QTableWidgetItem*>(item));
}

void QTableWidget_SetHorizontalHeaderLabels(void* ptr, struct QtWidgets_PackedString labels)
{
	static_cast<QTableWidget*>(ptr)->setHorizontalHeaderLabels(QString::fromUtf8(labels.data, labels.len).split("¡¦!", QString::SkipEmptyParts));
}

void QTableWidget_SetItem(void* ptr, int row, int column, void* item)
{
	static_cast<QTableWidget*>(ptr)->setItem(row, column, static_cast<QTableWidgetItem*>(item));
}

void QTableWidget_SetItemPrototype(void* ptr, void* item)
{
	static_cast<QTableWidget*>(ptr)->setItemPrototype(static_cast<QTableWidgetItem*>(item));
}

void QTableWidget_SetRangeSelected(void* ptr, void* ran, char sele)
{
	static_cast<QTableWidget*>(ptr)->setRangeSelected(*static_cast<QTableWidgetSelectionRange*>(ran), sele != 0);
}

void QTableWidget_SetRowCount(void* ptr, int rows)
{
	static_cast<QTableWidget*>(ptr)->setRowCount(rows);
}

void QTableWidget_SetVerticalHeaderItem(void* ptr, int row, void* item)
{
	static_cast<QTableWidget*>(ptr)->setVerticalHeaderItem(row, static_cast<QTableWidgetItem*>(item));
}

void QTableWidget_SetVerticalHeaderLabels(void* ptr, struct QtWidgets_PackedString labels)
{
	static_cast<QTableWidget*>(ptr)->setVerticalHeaderLabels(QString::fromUtf8(labels.data, labels.len).split("¡¦!", QString::SkipEmptyParts));
}

void QTableWidget_SortItems(void* ptr, int column, long long order)
{
	static_cast<QTableWidget*>(ptr)->sortItems(column, static_cast<Qt::SortOrder>(order));
}

long long QTableWidget_SupportedDropActions(void* ptr)
{
	return static_cast<QTableWidget*>(ptr)->supportedDropActions();
}

long long QTableWidget_SupportedDropActionsDefault(void* ptr)
{
		return static_cast<QTableWidget*>(ptr)->QTableWidget::supportedDropActions();
}

void* QTableWidget_TakeHorizontalHeaderItem(void* ptr, int column)
{
	return static_cast<QTableWidget*>(ptr)->takeHorizontalHeaderItem(column);
}

void* QTableWidget_TakeItem(void* ptr, int row, int column)
{
	return static_cast<QTableWidget*>(ptr)->takeItem(row, column);
}

void* QTableWidget_TakeVerticalHeaderItem(void* ptr, int row)
{
	return static_cast<QTableWidget*>(ptr)->takeVerticalHeaderItem(row);
}

void* QTableWidget_VerticalHeaderItem(void* ptr, int row)
{
	return static_cast<QTableWidget*>(ptr)->verticalHeaderItem(row);
}

int QTableWidget_VisualColumn(void* ptr, int logicalColumn)
{
	return static_cast<QTableWidget*>(ptr)->visualColumn(logicalColumn);
}

void* QTableWidget_VisualItemRect(void* ptr, void* item)
{
	return ({ QRect tmpValue = static_cast<QTableWidget*>(ptr)->visualItemRect(static_cast<QTableWidgetItem*>(item)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

int QTableWidget_VisualRow(void* ptr, int logicalRow)
{
	return static_cast<QTableWidget*>(ptr)->visualRow(logicalRow);
}

void QTableWidget_DestroyQTableWidget(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->~QTableWidget();
}

void QTableWidget_DestroyQTableWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QTableWidget___findItems_atList(void* ptr, int i)
{
	return ({QTableWidgetItem * tmp = static_cast<QList<QTableWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTableWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTableWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTableWidget___findItems_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTableWidgetItem *>();
}

void* QTableWidget___items_atList(void* ptr, int i)
{
	return ({QTableWidgetItem * tmp = static_cast<QList<QTableWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTableWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTableWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTableWidget___items_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTableWidgetItem *>();
}

void* QTableWidget___mimeData_items_atList(void* ptr, int i)
{
	return ({QTableWidgetItem * tmp = static_cast<QList<QTableWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTableWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTableWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTableWidget___mimeData_items_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTableWidgetItem *>();
}

void* QTableWidget___selectedItems_atList(void* ptr, int i)
{
	return ({QTableWidgetItem * tmp = static_cast<QList<QTableWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTableWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTableWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTableWidget___selectedItems_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTableWidgetItem *>();
}

void* QTableWidget___selectedRanges_atList(void* ptr, int i)
{
	return new QTableWidgetSelectionRange(({QTableWidgetSelectionRange tmp = static_cast<QList<QTableWidgetSelectionRange>*>(ptr)->at(i); if (i == static_cast<QList<QTableWidgetSelectionRange>*>(ptr)->size()-1) { static_cast<QList<QTableWidgetSelectionRange>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

void* QTableWidget___selectedRanges_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTableWidgetSelectionRange>();
}

class MyQTableWidgetItem: public QTableWidgetItem
{
public:
	MyQTableWidgetItem(int ty = Type) : QTableWidgetItem(ty) {QTableWidgetItem_QTableWidgetItem_QRegisterMetaType();};
	MyQTableWidgetItem(const QString &text, int ty = Type) : QTableWidgetItem(text, ty) {QTableWidgetItem_QTableWidgetItem_QRegisterMetaType();};
	MyQTableWidgetItem(const QIcon &icon, const QString &text, int ty = Type) : QTableWidgetItem(icon, text, ty) {QTableWidgetItem_QTableWidgetItem_QRegisterMetaType();};
	MyQTableWidgetItem(const QTableWidgetItem &other) : QTableWidgetItem(other) {QTableWidgetItem_QTableWidgetItem_QRegisterMetaType();};
	QTableWidgetItem * clone() const { return static_cast<QTableWidgetItem*>(callbackQTableWidgetItem_Clone(const_cast<void*>(static_cast<const void*>(this)))); };
	QVariant data(int role) const { return *static_cast<QVariant*>(callbackQTableWidgetItem_Data(const_cast<void*>(static_cast<const void*>(this)), role)); };
	void read(QDataStream & in) { callbackQTableWidgetItem_Read(this, static_cast<QDataStream*>(&in)); };
	void setData(int role, const QVariant & value) { callbackQTableWidgetItem_SetData(this, role, const_cast<QVariant*>(&value)); };
	void write(QDataStream & out) const { callbackQTableWidgetItem_Write(const_cast<void*>(static_cast<const void*>(this)), static_cast<QDataStream*>(&out)); };
	 ~MyQTableWidgetItem() { callbackQTableWidgetItem_DestroyQTableWidgetItem(this); };
};

Q_DECLARE_METATYPE(QTableWidgetItem*)
Q_DECLARE_METATYPE(MyQTableWidgetItem*)

int QTableWidgetItem_QTableWidgetItem_QRegisterMetaType(){qRegisterMetaType<QTableWidgetItem*>(); return qRegisterMetaType<MyQTableWidgetItem*>();}

void* QTableWidgetItem_NewQTableWidgetItem(int ty)
{
	return new MyQTableWidgetItem(ty);
}

void* QTableWidgetItem_NewQTableWidgetItem2(struct QtWidgets_PackedString text, int ty)
{
	return new MyQTableWidgetItem(QString::fromUtf8(text.data, text.len), ty);
}

void* QTableWidgetItem_NewQTableWidgetItem3(void* icon, struct QtWidgets_PackedString text, int ty)
{
	return new MyQTableWidgetItem(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), ty);
}

void* QTableWidgetItem_NewQTableWidgetItem4(void* other)
{
	return new MyQTableWidgetItem(*static_cast<QTableWidgetItem*>(other));
}

void* QTableWidgetItem_Background(void* ptr)
{
	return new QBrush(static_cast<QTableWidgetItem*>(ptr)->background());
}

long long QTableWidgetItem_CheckState(void* ptr)
{
	return static_cast<QTableWidgetItem*>(ptr)->checkState();
}

void* QTableWidgetItem_Clone(void* ptr)
{
	return static_cast<QTableWidgetItem*>(ptr)->clone();
}

void* QTableWidgetItem_CloneDefault(void* ptr)
{
		return static_cast<QTableWidgetItem*>(ptr)->QTableWidgetItem::clone();
}

int QTableWidgetItem_Column(void* ptr)
{
	return static_cast<QTableWidgetItem*>(ptr)->column();
}

void* QTableWidgetItem_Data(void* ptr, int role)
{
	return new QVariant(static_cast<QTableWidgetItem*>(ptr)->data(role));
}

void* QTableWidgetItem_DataDefault(void* ptr, int role)
{
		return new QVariant(static_cast<QTableWidgetItem*>(ptr)->QTableWidgetItem::data(role));
}

long long QTableWidgetItem_Flags(void* ptr)
{
	return static_cast<QTableWidgetItem*>(ptr)->flags();
}

void* QTableWidgetItem_Font(void* ptr)
{
	return new QFont(static_cast<QTableWidgetItem*>(ptr)->font());
}

void* QTableWidgetItem_Foreground(void* ptr)
{
	return new QBrush(static_cast<QTableWidgetItem*>(ptr)->foreground());
}

void* QTableWidgetItem_Icon(void* ptr)
{
	return new QIcon(static_cast<QTableWidgetItem*>(ptr)->icon());
}

char QTableWidgetItem_IsSelected(void* ptr)
{
	return static_cast<QTableWidgetItem*>(ptr)->isSelected();
}

void QTableWidgetItem_Read(void* ptr, void* in)
{
	static_cast<QTableWidgetItem*>(ptr)->read(*static_cast<QDataStream*>(in));
}

void QTableWidgetItem_ReadDefault(void* ptr, void* in)
{
		static_cast<QTableWidgetItem*>(ptr)->QTableWidgetItem::read(*static_cast<QDataStream*>(in));
}

int QTableWidgetItem_Row(void* ptr)
{
	return static_cast<QTableWidgetItem*>(ptr)->row();
}

void QTableWidgetItem_SetBackground(void* ptr, void* brush)
{
	static_cast<QTableWidgetItem*>(ptr)->setBackground(*static_cast<QBrush*>(brush));
}

void QTableWidgetItem_SetCheckState(void* ptr, long long state)
{
	static_cast<QTableWidgetItem*>(ptr)->setCheckState(static_cast<Qt::CheckState>(state));
}

void QTableWidgetItem_SetData(void* ptr, int role, void* value)
{
	static_cast<QTableWidgetItem*>(ptr)->setData(role, *static_cast<QVariant*>(value));
}

void QTableWidgetItem_SetDataDefault(void* ptr, int role, void* value)
{
		static_cast<QTableWidgetItem*>(ptr)->QTableWidgetItem::setData(role, *static_cast<QVariant*>(value));
}

void QTableWidgetItem_SetFlags(void* ptr, long long flags)
{
	static_cast<QTableWidgetItem*>(ptr)->setFlags(static_cast<Qt::ItemFlag>(flags));
}

void QTableWidgetItem_SetFont(void* ptr, void* font)
{
	static_cast<QTableWidgetItem*>(ptr)->setFont(*static_cast<QFont*>(font));
}

void QTableWidgetItem_SetForeground(void* ptr, void* brush)
{
	static_cast<QTableWidgetItem*>(ptr)->setForeground(*static_cast<QBrush*>(brush));
}

void QTableWidgetItem_SetIcon(void* ptr, void* icon)
{
	static_cast<QTableWidgetItem*>(ptr)->setIcon(*static_cast<QIcon*>(icon));
}

void QTableWidgetItem_SetSelected(void* ptr, char sele)
{
	static_cast<QTableWidgetItem*>(ptr)->setSelected(sele != 0);
}

void QTableWidgetItem_SetSizeHint(void* ptr, void* size)
{
	static_cast<QTableWidgetItem*>(ptr)->setSizeHint(*static_cast<QSize*>(size));
}

void QTableWidgetItem_SetStatusTip(void* ptr, struct QtWidgets_PackedString statusTip)
{
	static_cast<QTableWidgetItem*>(ptr)->setStatusTip(QString::fromUtf8(statusTip.data, statusTip.len));
}

void QTableWidgetItem_SetText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QTableWidgetItem*>(ptr)->setText(QString::fromUtf8(text.data, text.len));
}

void QTableWidgetItem_SetTextAlignment(void* ptr, int alignment)
{
	static_cast<QTableWidgetItem*>(ptr)->setTextAlignment(alignment);
}

void QTableWidgetItem_SetToolTip(void* ptr, struct QtWidgets_PackedString toolTip)
{
	static_cast<QTableWidgetItem*>(ptr)->setToolTip(QString::fromUtf8(toolTip.data, toolTip.len));
}

void QTableWidgetItem_SetWhatsThis(void* ptr, struct QtWidgets_PackedString whatsThis)
{
	static_cast<QTableWidgetItem*>(ptr)->setWhatsThis(QString::fromUtf8(whatsThis.data, whatsThis.len));
}

void* QTableWidgetItem_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableWidgetItem*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

struct QtWidgets_PackedString QTableWidgetItem_StatusTip(void* ptr)
{
	return ({ QByteArray* t934149 = new QByteArray(static_cast<QTableWidgetItem*>(ptr)->statusTip().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t934149->prepend("WHITESPACE").constData()+10), t934149->size()-10, t934149 }; });
}

void* QTableWidgetItem_TableWidget(void* ptr)
{
	return static_cast<QTableWidgetItem*>(ptr)->tableWidget();
}

struct QtWidgets_PackedString QTableWidgetItem_Text(void* ptr)
{
	return ({ QByteArray* tbdfc6c = new QByteArray(static_cast<QTableWidgetItem*>(ptr)->text().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tbdfc6c->prepend("WHITESPACE").constData()+10), tbdfc6c->size()-10, tbdfc6c }; });
}

int QTableWidgetItem_TextAlignment(void* ptr)
{
	return static_cast<QTableWidgetItem*>(ptr)->textAlignment();
}

struct QtWidgets_PackedString QTableWidgetItem_ToolTip(void* ptr)
{
	return ({ QByteArray* t8fa9fe = new QByteArray(static_cast<QTableWidgetItem*>(ptr)->toolTip().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t8fa9fe->prepend("WHITESPACE").constData()+10), t8fa9fe->size()-10, t8fa9fe }; });
}

int QTableWidgetItem_Type(void* ptr)
{
	return static_cast<QTableWidgetItem*>(ptr)->type();
}

struct QtWidgets_PackedString QTableWidgetItem_WhatsThis(void* ptr)
{
	return ({ QByteArray* t4664fc = new QByteArray(static_cast<QTableWidgetItem*>(ptr)->whatsThis().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t4664fc->prepend("WHITESPACE").constData()+10), t4664fc->size()-10, t4664fc }; });
}

void QTableWidgetItem_Write(void* ptr, void* out)
{
	static_cast<QTableWidgetItem*>(ptr)->write(*static_cast<QDataStream*>(out));
}

void QTableWidgetItem_WriteDefault(void* ptr, void* out)
{
		static_cast<QTableWidgetItem*>(ptr)->QTableWidgetItem::write(*static_cast<QDataStream*>(out));
}

void QTableWidgetItem_DestroyQTableWidgetItem(void* ptr)
{
	static_cast<QTableWidgetItem*>(ptr)->~QTableWidgetItem();
}

void QTableWidgetItem_DestroyQTableWidgetItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QTableWidgetItem___values_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<QWidgetItemData>();
}

void* QTableWidgetItem___setValues__newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QVector<QWidgetItemData>();
}

Q_DECLARE_METATYPE(QTableWidgetSelectionRange)
Q_DECLARE_METATYPE(QTableWidgetSelectionRange*)
void* QTableWidgetSelectionRange_NewQTableWidgetSelectionRange()
{
	return new QTableWidgetSelectionRange();
}

void* QTableWidgetSelectionRange_NewQTableWidgetSelectionRange2(int top, int left, int bottom, int right)
{
	return new QTableWidgetSelectionRange(top, left, bottom, right);
}

void* QTableWidgetSelectionRange_NewQTableWidgetSelectionRange3(void* other)
{
	return new QTableWidgetSelectionRange(*static_cast<QTableWidgetSelectionRange*>(other));
}

int QTableWidgetSelectionRange_BottomRow(void* ptr)
{
	return static_cast<QTableWidgetSelectionRange*>(ptr)->bottomRow();
}

int QTableWidgetSelectionRange_ColumnCount(void* ptr)
{
	return static_cast<QTableWidgetSelectionRange*>(ptr)->columnCount();
}

int QTableWidgetSelectionRange_LeftColumn(void* ptr)
{
	return static_cast<QTableWidgetSelectionRange*>(ptr)->leftColumn();
}

int QTableWidgetSelectionRange_RightColumn(void* ptr)
{
	return static_cast<QTableWidgetSelectionRange*>(ptr)->rightColumn();
}

int QTableWidgetSelectionRange_RowCount(void* ptr)
{
	return static_cast<QTableWidgetSelectionRange*>(ptr)->rowCount();
}

int QTableWidgetSelectionRange_TopRow(void* ptr)
{
	return static_cast<QTableWidgetSelectionRange*>(ptr)->topRow();
}

void QTableWidgetSelectionRange_DestroyQTableWidgetSelectionRange(void* ptr)
{
	static_cast<QTableWidgetSelectionRange*>(ptr)->~QTableWidgetSelectionRange();
}

class MyQTapAndHoldGesture: public QTapAndHoldGesture
{
public:
	 ~MyQTapAndHoldGesture() { callbackQTapAndHoldGesture_DestroyQTapAndHoldGesture(this); };
	void childEvent(QChildEvent * event) { callbackQGesture_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGesture_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGesture_CustomEvent(this, event); };
	void deleteLater() { callbackQGesture_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGesture_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGesture_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGesture_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGesture_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGesture_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGesture_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGesture_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QTapAndHoldGesture*)
Q_DECLARE_METATYPE(MyQTapAndHoldGesture*)

int QTapAndHoldGesture_QTapAndHoldGesture_QRegisterMetaType(){qRegisterMetaType<QTapAndHoldGesture*>(); return qRegisterMetaType<MyQTapAndHoldGesture*>();}

void* QTapAndHoldGesture_Position(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QTapAndHoldGesture*>(ptr)->position(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QTapAndHoldGesture_SetPosition(void* ptr, void* pos)
{
	static_cast<QTapAndHoldGesture*>(ptr)->setPosition(*static_cast<QPointF*>(pos));
}

void QTapAndHoldGesture_QTapAndHoldGesture_SetTimeout(int msecs)
{
	QTapAndHoldGesture::setTimeout(msecs);
}

int QTapAndHoldGesture_QTapAndHoldGesture_Timeout()
{
	return QTapAndHoldGesture::timeout();
}

void QTapAndHoldGesture_DestroyQTapAndHoldGesture(void* ptr)
{
	static_cast<QTapAndHoldGesture*>(ptr)->~QTapAndHoldGesture();
}

void QTapAndHoldGesture_DestroyQTapAndHoldGestureDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQTapGesture: public QTapGesture
{
public:
	 ~MyQTapGesture() { callbackQTapGesture_DestroyQTapGesture(this); };
	void childEvent(QChildEvent * event) { callbackQGesture_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGesture_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGesture_CustomEvent(this, event); };
	void deleteLater() { callbackQGesture_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGesture_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGesture_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGesture_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGesture_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGesture_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQGesture_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGesture_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QTapGesture*)
Q_DECLARE_METATYPE(MyQTapGesture*)

int QTapGesture_QTapGesture_QRegisterMetaType(){qRegisterMetaType<QTapGesture*>(); return qRegisterMetaType<MyQTapGesture*>();}

void* QTapGesture_Position(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QTapGesture*>(ptr)->position(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QTapGesture_SetPosition(void* ptr, void* pos)
{
	static_cast<QTapGesture*>(ptr)->setPosition(*static_cast<QPointF*>(pos));
}

void QTapGesture_DestroyQTapGesture(void* ptr)
{
	static_cast<QTapGesture*>(ptr)->~QTapGesture();
}

void QTapGesture_DestroyQTapGestureDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQTextBrowser: public QTextBrowser
{
public:
	MyQTextBrowser(QWidget *parent = Q_NULLPTR) : QTextBrowser(parent) {QTextBrowser_QTextBrowser_QRegisterMetaType();};
	void Signal_AnchorClicked(const QUrl & link) { callbackQTextBrowser_AnchorClicked(this, const_cast<QUrl*>(&link)); };
	void backward() { callbackQTextBrowser_Backward(this); };
	void Signal_BackwardAvailable(bool available) { callbackQTextBrowser_BackwardAvailable(this, available); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * ev) { callbackQWidget_FocusOutEvent(this, ev); };
	void forward() { callbackQTextBrowser_Forward(this); };
	void Signal_ForwardAvailable(bool available) { callbackQTextBrowser_ForwardAvailable(this, available); };
	void Signal_Highlighted(const QUrl & link) { callbackQTextBrowser_Highlighted(this, const_cast<QUrl*>(&link)); };
	void Signal_Highlighted2(const QString & link) { QByteArray* t4f0aa5 = new QByteArray(link.toUtf8()); QtWidgets_PackedString linkPacked = { const_cast<char*>(t4f0aa5->prepend("WHITESPACE").constData()+10), t4f0aa5->size()-10, t4f0aa5 };callbackQTextBrowser_Highlighted2(this, linkPacked); };
	void Signal_HistoryChanged() { callbackQTextBrowser_HistoryChanged(this); };
	void home() { callbackQTextBrowser_Home(this); };
	void keyPressEvent(QKeyEvent * ev) { callbackQWidget_KeyPressEvent(this, ev); };
	QVariant loadResource(int ty, const QUrl & name) { return *static_cast<QVariant*>(callbackQTextEdit_LoadResource(this, ty, const_cast<QUrl*>(&name))); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQWidget_PaintEvent(this, e); };
	void reload() { callbackQTextBrowser_Reload(this); };
	void setSource(const QUrl & name) { callbackQTextBrowser_SetSource(this, const_cast<QUrl*>(&name)); };
	void Signal_SourceChanged(const QUrl & src) { callbackQTextBrowser_SourceChanged(this, const_cast<QUrl*>(&src)); };
	void append(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQTextEdit_Append(this, textPacked); };
	bool canInsertFromMimeData(const QMimeData * source) const { return callbackQTextEdit_CanInsertFromMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(source)) != 0; };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void clear() { callbackQTextEdit_Clear(this); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void copy() { callbackQTextEdit_Copy(this); };
	void Signal_CopyAvailable(bool yes) { callbackQTextEdit_CopyAvailable(this, yes); };
	QMimeData * createMimeDataFromSelection() const { return static_cast<QMimeData*>(callbackQTextEdit_CreateMimeDataFromSelection(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_CurrentCharFormatChanged(const QTextCharFormat & ff) { callbackQTextEdit_CurrentCharFormatChanged(this, const_cast<QTextCharFormat*>(&ff)); };
	void Signal_CursorPositionChanged() { callbackQTextEdit_CursorPositionChanged(this); };
	void cut() { callbackQTextEdit_Cut(this); };
	void dragEnterEvent(QDragEnterEvent * e) { callbackQWidget_DragEnterEvent(this, e); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQWidget_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQWidget_DragMoveEvent(this, e); };
	void dropEvent(QDropEvent * e) { callbackQWidget_DropEvent(this, e); };
	void focusInEvent(QFocusEvent * e) { callbackQWidget_FocusInEvent(this, e); };
	void inputMethodEvent(QInputMethodEvent * e) { callbackQWidget_InputMethodEvent(this, e); };
	QVariant inputMethodQuery(Qt::InputMethodQuery property) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), property)); };
	void insertFromMimeData(const QMimeData * source) { callbackQTextEdit_InsertFromMimeData(this, const_cast<QMimeData*>(source)); };
	void insertHtml(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQTextEdit_InsertHtml(this, textPacked); };
	void insertPlainText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQTextEdit_InsertPlainText(this, textPacked); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQWidget_KeyReleaseEvent(this, e); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQWidget_MouseDoubleClickEvent(this, e); };
	void paste() { callbackQTextEdit_Paste(this); };
	void redo() { callbackQTextEdit_Redo(this); };
	void Signal_RedoAvailable(bool available) { callbackQTextEdit_RedoAvailable(this, available); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void scrollToAnchor(const QString & name) { QByteArray* t6ae999 = new QByteArray(name.toUtf8()); QtWidgets_PackedString namePacked = { const_cast<char*>(t6ae999->prepend("WHITESPACE").constData()+10), t6ae999->size()-10, t6ae999 };callbackQTextEdit_ScrollToAnchor(this, namePacked); };
	void selectAll() { callbackQTextEdit_SelectAll(this); };
	void Signal_SelectionChanged() { callbackQTextEdit_SelectionChanged(this); };
	void setAlignment(Qt::Alignment a) { callbackQTextEdit_SetAlignment(this, a); };
	void setCurrentFont(const QFont & ff) { callbackQTextEdit_SetCurrentFont(this, const_cast<QFont*>(&ff)); };
	void setFontFamily(const QString & fontFamily) { QByteArray* t5db177 = new QByteArray(fontFamily.toUtf8()); QtWidgets_PackedString fontFamilyPacked = { const_cast<char*>(t5db177->prepend("WHITESPACE").constData()+10), t5db177->size()-10, t5db177 };callbackQTextEdit_SetFontFamily(this, fontFamilyPacked); };
	void setFontItalic(bool italic) { callbackQTextEdit_SetFontItalic(this, italic); };
	void setFontPointSize(qreal s) { callbackQTextEdit_SetFontPointSize(this, s); };
	void setFontUnderline(bool underline) { callbackQTextEdit_SetFontUnderline(this, underline); };
	void setFontWeight(int weight) { callbackQTextEdit_SetFontWeight(this, weight); };
	void setHtml(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQTextEdit_SetHtml(this, textPacked); };
	void setPlainText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQTextEdit_SetPlainText(this, textPacked); };
	void setText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQTextEdit_SetText(this, textPacked); };
	void setTextBackgroundColor(const QColor & c) { callbackQTextEdit_SetTextBackgroundColor(this, const_cast<QColor*>(&c)); };
	void setTextColor(const QColor & c) { callbackQTextEdit_SetTextColor(this, const_cast<QColor*>(&c)); };
	void showEvent(QShowEvent * vqs) { callbackQWidget_ShowEvent(this, vqs); };
	void Signal_TextChanged() { callbackQTextEdit_TextChanged(this); };
	void undo() { callbackQTextEdit_Undo(this); };
	void Signal_UndoAvailable(bool available) { callbackQTextEdit_UndoAvailable(this, available); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void zoomIn(int ran) { callbackQTextEdit_ZoomIn(this, ran); };
	void zoomOut(int ran) { callbackQTextEdit_ZoomOut(this, ran); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QTextBrowser*)
Q_DECLARE_METATYPE(MyQTextBrowser*)

int QTextBrowser_QTextBrowser_QRegisterMetaType(){qRegisterMetaType<QTextBrowser*>(); return qRegisterMetaType<MyQTextBrowser*>();}

void* QTextBrowser_NewQTextBrowser(void* parent)
{
		return new MyQTextBrowser(static_cast<QWidget*>(parent));
}

void QTextBrowser_ConnectAnchorClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)(const QUrl &)>(&QTextBrowser::anchorClicked), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)(const QUrl &)>(&MyQTextBrowser::Signal_AnchorClicked), static_cast<Qt::ConnectionType>(t));
}

void QTextBrowser_DisconnectAnchorClicked(void* ptr)
{
	QObject::disconnect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)(const QUrl &)>(&QTextBrowser::anchorClicked), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)(const QUrl &)>(&MyQTextBrowser::Signal_AnchorClicked));
}

void QTextBrowser_AnchorClicked(void* ptr, void* link)
{
	static_cast<QTextBrowser*>(ptr)->anchorClicked(*static_cast<QUrl*>(link));
}

void QTextBrowser_Backward(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "backward");
}

void QTextBrowser_BackwardDefault(void* ptr)
{
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::backward();
}

void QTextBrowser_ConnectBackwardAvailable(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)(bool)>(&QTextBrowser::backwardAvailable), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)(bool)>(&MyQTextBrowser::Signal_BackwardAvailable), static_cast<Qt::ConnectionType>(t));
}

void QTextBrowser_DisconnectBackwardAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)(bool)>(&QTextBrowser::backwardAvailable), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)(bool)>(&MyQTextBrowser::Signal_BackwardAvailable));
}

void QTextBrowser_BackwardAvailable(void* ptr, char available)
{
	static_cast<QTextBrowser*>(ptr)->backwardAvailable(available != 0);
}

int QTextBrowser_BackwardHistoryCount(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->backwardHistoryCount();
}

void QTextBrowser_ClearHistory(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->clearHistory();
}

void QTextBrowser_Forward(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "forward");
}

void QTextBrowser_ForwardDefault(void* ptr)
{
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::forward();
}

void QTextBrowser_ConnectForwardAvailable(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)(bool)>(&QTextBrowser::forwardAvailable), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)(bool)>(&MyQTextBrowser::Signal_ForwardAvailable), static_cast<Qt::ConnectionType>(t));
}

void QTextBrowser_DisconnectForwardAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)(bool)>(&QTextBrowser::forwardAvailable), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)(bool)>(&MyQTextBrowser::Signal_ForwardAvailable));
}

void QTextBrowser_ForwardAvailable(void* ptr, char available)
{
	static_cast<QTextBrowser*>(ptr)->forwardAvailable(available != 0);
}

int QTextBrowser_ForwardHistoryCount(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->forwardHistoryCount();
}

void QTextBrowser_ConnectHighlighted(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)(const QUrl &)>(&QTextBrowser::highlighted), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)(const QUrl &)>(&MyQTextBrowser::Signal_Highlighted), static_cast<Qt::ConnectionType>(t));
}

void QTextBrowser_DisconnectHighlighted(void* ptr)
{
	QObject::disconnect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)(const QUrl &)>(&QTextBrowser::highlighted), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)(const QUrl &)>(&MyQTextBrowser::Signal_Highlighted));
}

void QTextBrowser_Highlighted(void* ptr, void* link)
{
	static_cast<QTextBrowser*>(ptr)->highlighted(*static_cast<QUrl*>(link));
}

void QTextBrowser_ConnectHighlighted2(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)(const QString &)>(&QTextBrowser::highlighted), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)(const QString &)>(&MyQTextBrowser::Signal_Highlighted2), static_cast<Qt::ConnectionType>(t));
}

void QTextBrowser_DisconnectHighlighted2(void* ptr)
{
	QObject::disconnect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)(const QString &)>(&QTextBrowser::highlighted), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)(const QString &)>(&MyQTextBrowser::Signal_Highlighted2));
}

void QTextBrowser_Highlighted2(void* ptr, struct QtWidgets_PackedString link)
{
	static_cast<QTextBrowser*>(ptr)->highlighted(QString::fromUtf8(link.data, link.len));
}

void QTextBrowser_ConnectHistoryChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)()>(&QTextBrowser::historyChanged), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)()>(&MyQTextBrowser::Signal_HistoryChanged), static_cast<Qt::ConnectionType>(t));
}

void QTextBrowser_DisconnectHistoryChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)()>(&QTextBrowser::historyChanged), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)()>(&MyQTextBrowser::Signal_HistoryChanged));
}

void QTextBrowser_HistoryChanged(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->historyChanged();
}

struct QtWidgets_PackedString QTextBrowser_HistoryTitle(void* ptr, int i)
{
	return ({ QByteArray* tc73fc4 = new QByteArray(static_cast<QTextBrowser*>(ptr)->historyTitle(i).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tc73fc4->prepend("WHITESPACE").constData()+10), tc73fc4->size()-10, tc73fc4 }; });
}

void* QTextBrowser_HistoryUrl(void* ptr, int i)
{
	return new QUrl(static_cast<QTextBrowser*>(ptr)->historyUrl(i));
}

void QTextBrowser_Home(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "home");
}

void QTextBrowser_HomeDefault(void* ptr)
{
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::home();
}

char QTextBrowser_IsBackwardAvailable(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->isBackwardAvailable();
}

char QTextBrowser_IsForwardAvailable(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->isForwardAvailable();
}

char QTextBrowser_OpenExternalLinks(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->openExternalLinks();
}

char QTextBrowser_OpenLinks(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->openLinks();
}

void QTextBrowser_Reload(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "reload");
}

void QTextBrowser_ReloadDefault(void* ptr)
{
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::reload();
}

struct QtWidgets_PackedString QTextBrowser_SearchPaths(void* ptr)
{
	return ({ QByteArray* t6868fa = new QByteArray(static_cast<QTextBrowser*>(ptr)->searchPaths().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t6868fa->prepend("WHITESPACE").constData()+10), t6868fa->size()-10, t6868fa }; });
}

void QTextBrowser_SetOpenExternalLinks(void* ptr, char open)
{
	static_cast<QTextBrowser*>(ptr)->setOpenExternalLinks(open != 0);
}

void QTextBrowser_SetOpenLinks(void* ptr, char open)
{
	static_cast<QTextBrowser*>(ptr)->setOpenLinks(open != 0);
}

void QTextBrowser_SetSearchPaths(void* ptr, struct QtWidgets_PackedString paths)
{
	static_cast<QTextBrowser*>(ptr)->setSearchPaths(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts));
}

void QTextBrowser_SetSource(void* ptr, void* name)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setSource", Q_ARG(const QUrl, *static_cast<QUrl*>(name)));
}

void QTextBrowser_SetSourceDefault(void* ptr, void* name)
{
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setSource(*static_cast<QUrl*>(name));
}

void* QTextBrowser_Source(void* ptr)
{
	return new QUrl(static_cast<QTextBrowser*>(ptr)->source());
}

void QTextBrowser_ConnectSourceChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)(const QUrl &)>(&QTextBrowser::sourceChanged), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)(const QUrl &)>(&MyQTextBrowser::Signal_SourceChanged), static_cast<Qt::ConnectionType>(t));
}

void QTextBrowser_DisconnectSourceChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)(const QUrl &)>(&QTextBrowser::sourceChanged), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)(const QUrl &)>(&MyQTextBrowser::Signal_SourceChanged));
}

void QTextBrowser_SourceChanged(void* ptr, void* src)
{
	static_cast<QTextBrowser*>(ptr)->sourceChanged(*static_cast<QUrl*>(src));
}

char QTextBrowser_IsReadOnly(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->isReadOnly();
}

void QTextBrowser_SetReadOnly(void* ptr, char readOnly)
{
	static_cast<QTextBrowser*>(ptr)->setReadOnly(readOnly != 0);
}

char QTextBrowser_IsUndoRedoEnabled(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->isUndoRedoEnabled();
}

void QTextBrowser_SetUndoRedoEnabled(void* ptr, char undoRedoEnabled)
{
	static_cast<QTextBrowser*>(ptr)->setUndoRedoEnabled(undoRedoEnabled != 0);
}

class MyQTextEdit: public QTextEdit
{
public:
	MyQTextEdit(QWidget *parent = Q_NULLPTR) : QTextEdit(parent) {QTextEdit_QTextEdit_QRegisterMetaType();};
	MyQTextEdit(const QString &text, QWidget *parent = Q_NULLPTR) : QTextEdit(text, parent) {QTextEdit_QTextEdit_QRegisterMetaType();};
	void append(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQTextEdit_Append(this, textPacked); };
	bool canInsertFromMimeData(const QMimeData * source) const { return callbackQTextEdit_CanInsertFromMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(source)) != 0; };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void clear() { callbackQTextEdit_Clear(this); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void copy() { callbackQTextEdit_Copy(this); };
	void Signal_CopyAvailable(bool yes) { callbackQTextEdit_CopyAvailable(this, yes); };
	QMimeData * createMimeDataFromSelection() const { return static_cast<QMimeData*>(callbackQTextEdit_CreateMimeDataFromSelection(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_CurrentCharFormatChanged(const QTextCharFormat & ff) { callbackQTextEdit_CurrentCharFormatChanged(this, const_cast<QTextCharFormat*>(&ff)); };
	void Signal_CursorPositionChanged() { callbackQTextEdit_CursorPositionChanged(this); };
	void cut() { callbackQTextEdit_Cut(this); };
	void dragEnterEvent(QDragEnterEvent * e) { callbackQWidget_DragEnterEvent(this, e); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQWidget_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQWidget_DragMoveEvent(this, e); };
	void dropEvent(QDropEvent * e) { callbackQWidget_DropEvent(this, e); };
	void focusInEvent(QFocusEvent * e) { callbackQWidget_FocusInEvent(this, e); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * e) { callbackQWidget_FocusOutEvent(this, e); };
	void inputMethodEvent(QInputMethodEvent * e) { callbackQWidget_InputMethodEvent(this, e); };
	QVariant inputMethodQuery(Qt::InputMethodQuery property) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), property)); };
	void insertFromMimeData(const QMimeData * source) { callbackQTextEdit_InsertFromMimeData(this, const_cast<QMimeData*>(source)); };
	void insertHtml(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQTextEdit_InsertHtml(this, textPacked); };
	void insertPlainText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQTextEdit_InsertPlainText(this, textPacked); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQWidget_KeyReleaseEvent(this, e); };
	QVariant loadResource(int ty, const QUrl & name) { return *static_cast<QVariant*>(callbackQTextEdit_LoadResource(this, ty, const_cast<QUrl*>(&name))); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQWidget_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void paste() { callbackQTextEdit_Paste(this); };
	void redo() { callbackQTextEdit_Redo(this); };
	void Signal_RedoAvailable(bool available) { callbackQTextEdit_RedoAvailable(this, available); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void scrollToAnchor(const QString & name) { QByteArray* t6ae999 = new QByteArray(name.toUtf8()); QtWidgets_PackedString namePacked = { const_cast<char*>(t6ae999->prepend("WHITESPACE").constData()+10), t6ae999->size()-10, t6ae999 };callbackQTextEdit_ScrollToAnchor(this, namePacked); };
	void selectAll() { callbackQTextEdit_SelectAll(this); };
	void Signal_SelectionChanged() { callbackQTextEdit_SelectionChanged(this); };
	void setAlignment(Qt::Alignment a) { callbackQTextEdit_SetAlignment(this, a); };
	void setCurrentFont(const QFont & ff) { callbackQTextEdit_SetCurrentFont(this, const_cast<QFont*>(&ff)); };
	void setFontFamily(const QString & fontFamily) { QByteArray* t5db177 = new QByteArray(fontFamily.toUtf8()); QtWidgets_PackedString fontFamilyPacked = { const_cast<char*>(t5db177->prepend("WHITESPACE").constData()+10), t5db177->size()-10, t5db177 };callbackQTextEdit_SetFontFamily(this, fontFamilyPacked); };
	void setFontItalic(bool italic) { callbackQTextEdit_SetFontItalic(this, italic); };
	void setFontPointSize(qreal s) { callbackQTextEdit_SetFontPointSize(this, s); };
	void setFontUnderline(bool underline) { callbackQTextEdit_SetFontUnderline(this, underline); };
	void setFontWeight(int weight) { callbackQTextEdit_SetFontWeight(this, weight); };
	void setHtml(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQTextEdit_SetHtml(this, textPacked); };
	void setPlainText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQTextEdit_SetPlainText(this, textPacked); };
	void setText(const QString & text) { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };callbackQTextEdit_SetText(this, textPacked); };
	void setTextBackgroundColor(const QColor & c) { callbackQTextEdit_SetTextBackgroundColor(this, const_cast<QColor*>(&c)); };
	void setTextColor(const QColor & c) { callbackQTextEdit_SetTextColor(this, const_cast<QColor*>(&c)); };
	void showEvent(QShowEvent * vqs) { callbackQWidget_ShowEvent(this, vqs); };
	void Signal_TextChanged() { callbackQTextEdit_TextChanged(this); };
	void undo() { callbackQTextEdit_Undo(this); };
	void Signal_UndoAvailable(bool available) { callbackQTextEdit_UndoAvailable(this, available); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void zoomIn(int ran) { callbackQTextEdit_ZoomIn(this, ran); };
	void zoomOut(int ran) { callbackQTextEdit_ZoomOut(this, ran); };
	 ~MyQTextEdit() { callbackQTextEdit_DestroyQTextEdit(this); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QTextEdit*)
Q_DECLARE_METATYPE(MyQTextEdit*)

int QTextEdit_QTextEdit_QRegisterMetaType(){qRegisterMetaType<QTextEdit*>(); return qRegisterMetaType<MyQTextEdit*>();}

void* QTextEdit_NewQTextEdit(void* parent)
{
		return new MyQTextEdit(static_cast<QWidget*>(parent));
}

void* QTextEdit_NewQTextEdit2(struct QtWidgets_PackedString text, void* parent)
{
		return new MyQTextEdit(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(parent));
}

char QTextEdit_AcceptRichText(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->acceptRichText();
}

long long QTextEdit_Alignment(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->alignment();
}

struct QtWidgets_PackedString QTextEdit_AnchorAt(void* ptr, void* pos)
{
	return ({ QByteArray* t883a22 = new QByteArray(static_cast<QTextEdit*>(ptr)->anchorAt(*static_cast<QPoint*>(pos)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t883a22->prepend("WHITESPACE").constData()+10), t883a22->size()-10, t883a22 }; });
}

void QTextEdit_Append(void* ptr, struct QtWidgets_PackedString text)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "append", Q_ARG(const QString, QString::fromUtf8(text.data, text.len)));
}

void QTextEdit_AppendDefault(void* ptr, struct QtWidgets_PackedString text)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::append(QString::fromUtf8(text.data, text.len));
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::append(QString::fromUtf8(text.data, text.len));
	}
}

long long QTextEdit_AutoFormatting(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->autoFormatting();
}

char QTextEdit_CanInsertFromMimeData(void* ptr, void* source)
{
	return static_cast<QTextEdit*>(ptr)->canInsertFromMimeData(static_cast<QMimeData*>(source));
}

char QTextEdit_CanInsertFromMimeDataDefault(void* ptr, void* source)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextBrowser*>(ptr)->QTextBrowser::canInsertFromMimeData(static_cast<QMimeData*>(source));
	} else {
		return static_cast<QTextEdit*>(ptr)->QTextEdit::canInsertFromMimeData(static_cast<QMimeData*>(source));
	}
}

char QTextEdit_CanPaste(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->canPaste();
}

void QTextEdit_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "clear");
}

void QTextEdit_ClearDefault(void* ptr)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::clear();
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::clear();
	}
}

void QTextEdit_Copy(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "copy");
}

void QTextEdit_CopyDefault(void* ptr)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::copy();
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::copy();
	}
}

void QTextEdit_ConnectCopyAvailable(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)(bool)>(&QTextEdit::copyAvailable), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)(bool)>(&MyQTextEdit::Signal_CopyAvailable), static_cast<Qt::ConnectionType>(t));
}

void QTextEdit_DisconnectCopyAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)(bool)>(&QTextEdit::copyAvailable), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)(bool)>(&MyQTextEdit::Signal_CopyAvailable));
}

void QTextEdit_CopyAvailable(void* ptr, char yes)
{
	static_cast<QTextEdit*>(ptr)->copyAvailable(yes != 0);
}

void* QTextEdit_CreateMimeDataFromSelection(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->createMimeDataFromSelection();
}

void* QTextEdit_CreateMimeDataFromSelectionDefault(void* ptr)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextBrowser*>(ptr)->QTextBrowser::createMimeDataFromSelection();
	} else {
		return static_cast<QTextEdit*>(ptr)->QTextEdit::createMimeDataFromSelection();
	}
}

void* QTextEdit_CreateStandardContextMenu(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->createStandardContextMenu();
}

void* QTextEdit_CreateStandardContextMenu2(void* ptr, void* position)
{
	return static_cast<QTextEdit*>(ptr)->createStandardContextMenu(*static_cast<QPoint*>(position));
}

void* QTextEdit_CurrentCharFormat(void* ptr)
{
	return new QTextCharFormat(static_cast<QTextEdit*>(ptr)->currentCharFormat());
}

void QTextEdit_ConnectCurrentCharFormatChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)(const QTextCharFormat &)>(&QTextEdit::currentCharFormatChanged), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)(const QTextCharFormat &)>(&MyQTextEdit::Signal_CurrentCharFormatChanged), static_cast<Qt::ConnectionType>(t));
}

void QTextEdit_DisconnectCurrentCharFormatChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)(const QTextCharFormat &)>(&QTextEdit::currentCharFormatChanged), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)(const QTextCharFormat &)>(&MyQTextEdit::Signal_CurrentCharFormatChanged));
}

void QTextEdit_CurrentCharFormatChanged(void* ptr, void* ff)
{
	static_cast<QTextEdit*>(ptr)->currentCharFormatChanged(*static_cast<QTextCharFormat*>(ff));
}

void* QTextEdit_CurrentFont(void* ptr)
{
	return new QFont(static_cast<QTextEdit*>(ptr)->currentFont());
}

void* QTextEdit_CursorForPosition(void* ptr, void* pos)
{
	return new QTextCursor(static_cast<QTextEdit*>(ptr)->cursorForPosition(*static_cast<QPoint*>(pos)));
}

void QTextEdit_ConnectCursorPositionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)()>(&QTextEdit::cursorPositionChanged), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)()>(&MyQTextEdit::Signal_CursorPositionChanged), static_cast<Qt::ConnectionType>(t));
}

void QTextEdit_DisconnectCursorPositionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)()>(&QTextEdit::cursorPositionChanged), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)()>(&MyQTextEdit::Signal_CursorPositionChanged));
}

void QTextEdit_CursorPositionChanged(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->cursorPositionChanged();
}

void* QTextEdit_CursorRect(void* ptr, void* cursor)
{
	return ({ QRect tmpValue = static_cast<QTextEdit*>(ptr)->cursorRect(*static_cast<QTextCursor*>(cursor)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QTextEdit_CursorRect2(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QTextEdit*>(ptr)->cursorRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

int QTextEdit_CursorWidth(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->cursorWidth();
}

void QTextEdit_Cut(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "cut");
}

void QTextEdit_CutDefault(void* ptr)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::cut();
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::cut();
	}
}

void* QTextEdit_Document(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->document();
}

struct QtWidgets_PackedString QTextEdit_DocumentTitle(void* ptr)
{
	return ({ QByteArray* td339b8 = new QByteArray(static_cast<QTextEdit*>(ptr)->documentTitle().toUtf8()); QtWidgets_PackedString { const_cast<char*>(td339b8->prepend("WHITESPACE").constData()+10), td339b8->size()-10, td339b8 }; });
}

void QTextEdit_EnsureCursorVisible(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->ensureCursorVisible();
}

char QTextEdit_Find(void* ptr, struct QtWidgets_PackedString exp, long long options)
{
	return static_cast<QTextEdit*>(ptr)->find(QString::fromUtf8(exp.data, exp.len), static_cast<QTextDocument::FindFlag>(options));
}

char QTextEdit_Find2(void* ptr, void* exp, long long options)
{
	return static_cast<QTextEdit*>(ptr)->find(*static_cast<QRegExp*>(exp), static_cast<QTextDocument::FindFlag>(options));
}

char QTextEdit_Find3(void* ptr, void* exp, long long options)
{
	return static_cast<QTextEdit*>(ptr)->find(*static_cast<QRegularExpression*>(exp), static_cast<QTextDocument::FindFlag>(options));
}

struct QtWidgets_PackedString QTextEdit_FontFamily(void* ptr)
{
	return ({ QByteArray* tf50401 = new QByteArray(static_cast<QTextEdit*>(ptr)->fontFamily().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tf50401->prepend("WHITESPACE").constData()+10), tf50401->size()-10, tf50401 }; });
}

char QTextEdit_FontItalic(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->fontItalic();
}

double QTextEdit_FontPointSize(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->fontPointSize();
}

char QTextEdit_FontUnderline(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->fontUnderline();
}

int QTextEdit_FontWeight(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->fontWeight();
}

void QTextEdit_InsertFromMimeData(void* ptr, void* source)
{
	static_cast<QTextEdit*>(ptr)->insertFromMimeData(static_cast<QMimeData*>(source));
}

void QTextEdit_InsertFromMimeDataDefault(void* ptr, void* source)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::insertFromMimeData(static_cast<QMimeData*>(source));
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::insertFromMimeData(static_cast<QMimeData*>(source));
	}
}

void QTextEdit_InsertHtml(void* ptr, struct QtWidgets_PackedString text)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "insertHtml", Q_ARG(const QString, QString::fromUtf8(text.data, text.len)));
}

void QTextEdit_InsertHtmlDefault(void* ptr, struct QtWidgets_PackedString text)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::insertHtml(QString::fromUtf8(text.data, text.len));
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::insertHtml(QString::fromUtf8(text.data, text.len));
	}
}

void QTextEdit_InsertPlainText(void* ptr, struct QtWidgets_PackedString text)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "insertPlainText", Q_ARG(const QString, QString::fromUtf8(text.data, text.len)));
}

void QTextEdit_InsertPlainTextDefault(void* ptr, struct QtWidgets_PackedString text)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::insertPlainText(QString::fromUtf8(text.data, text.len));
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::insertPlainText(QString::fromUtf8(text.data, text.len));
	}
}

char QTextEdit_IsReadOnly(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->isReadOnly();
}

char QTextEdit_IsUndoRedoEnabled(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->isUndoRedoEnabled();
}

int QTextEdit_LineWrapColumnOrWidth(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->lineWrapColumnOrWidth();
}

long long QTextEdit_LineWrapMode(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->lineWrapMode();
}

void* QTextEdit_LoadResource(void* ptr, int ty, void* name)
{
	return new QVariant(static_cast<QTextEdit*>(ptr)->loadResource(ty, *static_cast<QUrl*>(name)));
}

void* QTextEdit_LoadResourceDefault(void* ptr, int ty, void* name)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QTextBrowser*>(ptr)->QTextBrowser::loadResource(ty, *static_cast<QUrl*>(name)));
	} else {
		return new QVariant(static_cast<QTextEdit*>(ptr)->QTextEdit::loadResource(ty, *static_cast<QUrl*>(name)));
	}
}

void QTextEdit_MergeCurrentCharFormat(void* ptr, void* modifier)
{
	static_cast<QTextEdit*>(ptr)->mergeCurrentCharFormat(*static_cast<QTextCharFormat*>(modifier));
}

void QTextEdit_MoveCursor(void* ptr, long long operation, long long mode)
{
	static_cast<QTextEdit*>(ptr)->moveCursor(static_cast<QTextCursor::MoveOperation>(operation), static_cast<QTextCursor::MoveMode>(mode));
}

char QTextEdit_OverwriteMode(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->overwriteMode();
}

void QTextEdit_Paste(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "paste");
}

void QTextEdit_PasteDefault(void* ptr)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::paste();
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::paste();
	}
}

struct QtWidgets_PackedString QTextEdit_PlaceholderText(void* ptr)
{
	return ({ QByteArray* t79a2c0 = new QByteArray(static_cast<QTextEdit*>(ptr)->placeholderText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t79a2c0->prepend("WHITESPACE").constData()+10), t79a2c0->size()-10, t79a2c0 }; });
}

void QTextEdit_Print(void* ptr, void* printer)
{
#ifndef Q_OS_IOS
	static_cast<QTextEdit*>(ptr)->print(static_cast<QPagedPaintDevice*>(printer));
#endif
}

void QTextEdit_Redo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "redo");
}

void QTextEdit_RedoDefault(void* ptr)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::redo();
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::redo();
	}
}

void QTextEdit_ConnectRedoAvailable(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)(bool)>(&QTextEdit::redoAvailable), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)(bool)>(&MyQTextEdit::Signal_RedoAvailable), static_cast<Qt::ConnectionType>(t));
}

void QTextEdit_DisconnectRedoAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)(bool)>(&QTextEdit::redoAvailable), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)(bool)>(&MyQTextEdit::Signal_RedoAvailable));
}

void QTextEdit_RedoAvailable(void* ptr, char available)
{
	static_cast<QTextEdit*>(ptr)->redoAvailable(available != 0);
}

void QTextEdit_ScrollToAnchor(void* ptr, struct QtWidgets_PackedString name)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "scrollToAnchor", Q_ARG(const QString, QString::fromUtf8(name.data, name.len)));
}

void QTextEdit_ScrollToAnchorDefault(void* ptr, struct QtWidgets_PackedString name)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::scrollToAnchor(QString::fromUtf8(name.data, name.len));
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::scrollToAnchor(QString::fromUtf8(name.data, name.len));
	}
}

void QTextEdit_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "selectAll");
}

void QTextEdit_SelectAllDefault(void* ptr)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::selectAll();
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::selectAll();
	}
}

void QTextEdit_ConnectSelectionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)()>(&QTextEdit::selectionChanged), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)()>(&MyQTextEdit::Signal_SelectionChanged), static_cast<Qt::ConnectionType>(t));
}

void QTextEdit_DisconnectSelectionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)()>(&QTextEdit::selectionChanged), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)()>(&MyQTextEdit::Signal_SelectionChanged));
}

void QTextEdit_SelectionChanged(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->selectionChanged();
}

void QTextEdit_SetAcceptRichText(void* ptr, char accept)
{
	static_cast<QTextEdit*>(ptr)->setAcceptRichText(accept != 0);
}

void QTextEdit_SetAlignment(void* ptr, long long a)
{
	qRegisterMetaType<Qt::Alignment>();
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setAlignment", Q_ARG(Qt::Alignment, static_cast<Qt::Alignment>(static_cast<Qt::AlignmentFlag>(a))));
}

void QTextEdit_SetAlignmentDefault(void* ptr, long long a)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setAlignment(static_cast<Qt::AlignmentFlag>(a));
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setAlignment(static_cast<Qt::AlignmentFlag>(a));
	}
}

void QTextEdit_SetAutoFormatting(void* ptr, long long features)
{
	static_cast<QTextEdit*>(ptr)->setAutoFormatting(static_cast<QTextEdit::AutoFormattingFlag>(features));
}

void QTextEdit_SetCurrentCharFormat(void* ptr, void* format)
{
	static_cast<QTextEdit*>(ptr)->setCurrentCharFormat(*static_cast<QTextCharFormat*>(format));
}

void QTextEdit_SetCurrentFont(void* ptr, void* ff)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setCurrentFont", Q_ARG(const QFont, *static_cast<QFont*>(ff)));
}

void QTextEdit_SetCurrentFontDefault(void* ptr, void* ff)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setCurrentFont(*static_cast<QFont*>(ff));
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setCurrentFont(*static_cast<QFont*>(ff));
	}
}

void QTextEdit_SetCursorWidth(void* ptr, int width)
{
	static_cast<QTextEdit*>(ptr)->setCursorWidth(width);
}

void QTextEdit_SetDocument(void* ptr, void* document)
{
	static_cast<QTextEdit*>(ptr)->setDocument(static_cast<QTextDocument*>(document));
}

void QTextEdit_SetDocumentTitle(void* ptr, struct QtWidgets_PackedString title)
{
	static_cast<QTextEdit*>(ptr)->setDocumentTitle(QString::fromUtf8(title.data, title.len));
}

void QTextEdit_SetFontFamily(void* ptr, struct QtWidgets_PackedString fontFamily)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setFontFamily", Q_ARG(const QString, QString::fromUtf8(fontFamily.data, fontFamily.len)));
}

void QTextEdit_SetFontFamilyDefault(void* ptr, struct QtWidgets_PackedString fontFamily)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setFontFamily(QString::fromUtf8(fontFamily.data, fontFamily.len));
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setFontFamily(QString::fromUtf8(fontFamily.data, fontFamily.len));
	}
}

void QTextEdit_SetFontItalic(void* ptr, char italic)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setFontItalic", Q_ARG(bool, italic != 0));
}

void QTextEdit_SetFontItalicDefault(void* ptr, char italic)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setFontItalic(italic != 0);
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setFontItalic(italic != 0);
	}
}

void QTextEdit_SetFontPointSize(void* ptr, double s)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setFontPointSize", Q_ARG(qreal, s));
}

void QTextEdit_SetFontPointSizeDefault(void* ptr, double s)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setFontPointSize(s);
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setFontPointSize(s);
	}
}

void QTextEdit_SetFontUnderline(void* ptr, char underline)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setFontUnderline", Q_ARG(bool, underline != 0));
}

void QTextEdit_SetFontUnderlineDefault(void* ptr, char underline)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setFontUnderline(underline != 0);
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setFontUnderline(underline != 0);
	}
}

void QTextEdit_SetFontWeight(void* ptr, int weight)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setFontWeight", Q_ARG(int, weight));
}

void QTextEdit_SetFontWeightDefault(void* ptr, int weight)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setFontWeight(weight);
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setFontWeight(weight);
	}
}

void QTextEdit_SetHtml(void* ptr, struct QtWidgets_PackedString text)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setHtml", Q_ARG(const QString, QString::fromUtf8(text.data, text.len)));
}

void QTextEdit_SetHtmlDefault(void* ptr, struct QtWidgets_PackedString text)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setHtml(QString::fromUtf8(text.data, text.len));
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setHtml(QString::fromUtf8(text.data, text.len));
	}
}

void QTextEdit_SetLineWrapColumnOrWidth(void* ptr, int w)
{
	static_cast<QTextEdit*>(ptr)->setLineWrapColumnOrWidth(w);
}

void QTextEdit_SetLineWrapMode(void* ptr, long long mode)
{
	static_cast<QTextEdit*>(ptr)->setLineWrapMode(static_cast<QTextEdit::LineWrapMode>(mode));
}

void QTextEdit_SetOverwriteMode(void* ptr, char overwrite)
{
	static_cast<QTextEdit*>(ptr)->setOverwriteMode(overwrite != 0);
}

void QTextEdit_SetPlaceholderText(void* ptr, struct QtWidgets_PackedString placeholderText)
{
	static_cast<QTextEdit*>(ptr)->setPlaceholderText(QString::fromUtf8(placeholderText.data, placeholderText.len));
}

void QTextEdit_SetPlainText(void* ptr, struct QtWidgets_PackedString text)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setPlainText", Q_ARG(const QString, QString::fromUtf8(text.data, text.len)));
}

void QTextEdit_SetPlainTextDefault(void* ptr, struct QtWidgets_PackedString text)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setPlainText(QString::fromUtf8(text.data, text.len));
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setPlainText(QString::fromUtf8(text.data, text.len));
	}
}

void QTextEdit_SetReadOnly(void* ptr, char ro)
{
	static_cast<QTextEdit*>(ptr)->setReadOnly(ro != 0);
}

void QTextEdit_SetTabChangesFocus(void* ptr, char b)
{
	static_cast<QTextEdit*>(ptr)->setTabChangesFocus(b != 0);
}

void QTextEdit_SetTabStopDistance(void* ptr, double distance)
{
	static_cast<QTextEdit*>(ptr)->setTabStopDistance(distance);
}

void QTextEdit_SetTabStopWidth(void* ptr, int width)
{
	static_cast<QTextEdit*>(ptr)->setTabStopWidth(width);
}

void QTextEdit_SetText(void* ptr, struct QtWidgets_PackedString text)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setText", Q_ARG(const QString, QString::fromUtf8(text.data, text.len)));
}

void QTextEdit_SetTextDefault(void* ptr, struct QtWidgets_PackedString text)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setText(QString::fromUtf8(text.data, text.len));
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setText(QString::fromUtf8(text.data, text.len));
	}
}

void QTextEdit_SetTextBackgroundColor(void* ptr, void* c)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setTextBackgroundColor", Q_ARG(const QColor, *static_cast<QColor*>(c)));
}

void QTextEdit_SetTextBackgroundColorDefault(void* ptr, void* c)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setTextBackgroundColor(*static_cast<QColor*>(c));
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setTextBackgroundColor(*static_cast<QColor*>(c));
	}
}

void QTextEdit_SetTextColor(void* ptr, void* c)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setTextColor", Q_ARG(const QColor, *static_cast<QColor*>(c)));
}

void QTextEdit_SetTextColorDefault(void* ptr, void* c)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setTextColor(*static_cast<QColor*>(c));
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setTextColor(*static_cast<QColor*>(c));
	}
}

void QTextEdit_SetTextCursor(void* ptr, void* cursor)
{
	static_cast<QTextEdit*>(ptr)->setTextCursor(*static_cast<QTextCursor*>(cursor));
}

void QTextEdit_SetTextInteractionFlags(void* ptr, long long flags)
{
	static_cast<QTextEdit*>(ptr)->setTextInteractionFlags(static_cast<Qt::TextInteractionFlag>(flags));
}

void QTextEdit_SetUndoRedoEnabled(void* ptr, char enable)
{
	static_cast<QTextEdit*>(ptr)->setUndoRedoEnabled(enable != 0);
}

void QTextEdit_SetWordWrapMode(void* ptr, long long policy)
{
	static_cast<QTextEdit*>(ptr)->setWordWrapMode(static_cast<QTextOption::WrapMode>(policy));
}

char QTextEdit_TabChangesFocus(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->tabChangesFocus();
}

double QTextEdit_TabStopDistance(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->tabStopDistance();
}

int QTextEdit_TabStopWidth(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->tabStopWidth();
}

void* QTextEdit_TextBackgroundColor(void* ptr)
{
	return new QColor(static_cast<QTextEdit*>(ptr)->textBackgroundColor());
}

void QTextEdit_ConnectTextChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)()>(&QTextEdit::textChanged), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)()>(&MyQTextEdit::Signal_TextChanged), static_cast<Qt::ConnectionType>(t));
}

void QTextEdit_DisconnectTextChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)()>(&QTextEdit::textChanged), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)()>(&MyQTextEdit::Signal_TextChanged));
}

void QTextEdit_TextChanged(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->textChanged();
}

void* QTextEdit_TextColor(void* ptr)
{
	return new QColor(static_cast<QTextEdit*>(ptr)->textColor());
}

void* QTextEdit_TextCursor(void* ptr)
{
	return new QTextCursor(static_cast<QTextEdit*>(ptr)->textCursor());
}

long long QTextEdit_TextInteractionFlags(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->textInteractionFlags();
}

struct QtWidgets_PackedString QTextEdit_ToHtml(void* ptr)
{
	return ({ QByteArray* t9adf2b = new QByteArray(static_cast<QTextEdit*>(ptr)->toHtml().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t9adf2b->prepend("WHITESPACE").constData()+10), t9adf2b->size()-10, t9adf2b }; });
}

struct QtWidgets_PackedString QTextEdit_ToPlainText(void* ptr)
{
	return ({ QByteArray* te62381 = new QByteArray(static_cast<QTextEdit*>(ptr)->toPlainText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(te62381->prepend("WHITESPACE").constData()+10), te62381->size()-10, te62381 }; });
}

void QTextEdit_Undo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "undo");
}

void QTextEdit_UndoDefault(void* ptr)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::undo();
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::undo();
	}
}

void QTextEdit_ConnectUndoAvailable(void* ptr, long long t)
{
	QObject::connect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)(bool)>(&QTextEdit::undoAvailable), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)(bool)>(&MyQTextEdit::Signal_UndoAvailable), static_cast<Qt::ConnectionType>(t));
}

void QTextEdit_DisconnectUndoAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)(bool)>(&QTextEdit::undoAvailable), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)(bool)>(&MyQTextEdit::Signal_UndoAvailable));
}

void QTextEdit_UndoAvailable(void* ptr, char available)
{
	static_cast<QTextEdit*>(ptr)->undoAvailable(available != 0);
}

long long QTextEdit_WordWrapMode(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->wordWrapMode();
}

void QTextEdit_ZoomIn(void* ptr, int ran)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "zoomIn", Q_ARG(int, ran));
}

void QTextEdit_ZoomInDefault(void* ptr, int ran)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::zoomIn(ran);
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::zoomIn(ran);
	}
}

void QTextEdit_ZoomOut(void* ptr, int ran)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "zoomOut", Q_ARG(int, ran));
}

void QTextEdit_ZoomOutDefault(void* ptr, int ran)
{
	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::zoomOut(ran);
	} else {
		static_cast<QTextEdit*>(ptr)->QTextEdit::zoomOut(ran);
	}
}

void QTextEdit_DestroyQTextEdit(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->~QTextEdit();
}

void QTextEdit_DestroyQTextEditDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

Q_DECLARE_METATYPE(QTileRules*)
void* QTileRules_NewQTileRules(long long horizontalRule, long long verticalRule)
{
	return new QTileRules(static_cast<Qt::TileRule>(horizontalRule), static_cast<Qt::TileRule>(verticalRule));
}

void* QTileRules_NewQTileRules2(long long rule)
{
	return new QTileRules(static_cast<Qt::TileRule>(rule));
}

class MyQTimeEdit: public QTimeEdit
{
public:
	MyQTimeEdit(QWidget *parent = Q_NULLPTR) : QTimeEdit(parent) {QTimeEdit_QTimeEdit_QRegisterMetaType();};
	MyQTimeEdit(const QTime &ti, QWidget *parent = Q_NULLPTR) : QTimeEdit(ti, parent) {QTimeEdit_QTimeEdit_QRegisterMetaType();};
	 ~MyQTimeEdit() { callbackQTimeEdit_DestroyQTimeEdit(this); };
	void clear() { callbackQDateTimeEdit_Clear(this); };
	void Signal_DateChanged(const QDate & date) { callbackQDateTimeEdit_DateChanged(this, const_cast<QDate*>(&date)); };
	void Signal_DateTimeChanged(const QDateTime & datetime) { callbackQDateTimeEdit_DateTimeChanged(this, const_cast<QDateTime*>(&datetime)); };
	QDateTime dateTimeFromText(const QString & text) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };return *static_cast<QDateTime*>(callbackQDateTimeEdit_DateTimeFromText(const_cast<void*>(static_cast<const void*>(this)), textPacked)); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void fixup(QString & input) const { QByteArray* t140f86 = new QByteArray(input.toUtf8()); QtWidgets_PackedString inputPacked = { const_cast<char*>(t140f86->prepend("WHITESPACE").constData()+10), t140f86->size()-10, t140f86 };callbackQAbstractSpinBox_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void setDate(const QDate & date) { callbackQDateTimeEdit_SetDate(this, const_cast<QDate*>(&date)); };
	void setDateTime(const QDateTime & dateTime) { callbackQDateTimeEdit_SetDateTime(this, const_cast<QDateTime*>(&dateTime)); };
	void setTime(const QTime & ti) { callbackQDateTimeEdit_SetTime(this, const_cast<QTime*>(&ti)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void stepBy(int steps) { callbackQAbstractSpinBox_StepBy(this, steps); };
	QAbstractSpinBox::StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQAbstractSpinBox_StepEnabled(const_cast<void*>(static_cast<const void*>(this)))); };
	QString textFromDateTime(const QDateTime & dateTime) const { return ({ QtWidgets_PackedString tempVal = callbackQDateTimeEdit_TextFromDateTime(const_cast<void*>(static_cast<const void*>(this)), const_cast<QDateTime*>(&dateTime)); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
	void Signal_TimeChanged(const QTime & ti) { callbackQDateTimeEdit_TimeChanged(this, const_cast<QTime*>(&ti)); };
	QValidator::State validate(QString & text, int & pos) const { QByteArray* t372ea0 = new QByteArray(text.toUtf8()); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0->prepend("WHITESPACE").constData()+10), t372ea0->size()-10, t372ea0 };return static_cast<QValidator::State>(callbackQAbstractSpinBox_Validate(const_cast<void*>(static_cast<const void*>(this)), textPacked, pos)); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_EditingFinished() { callbackQAbstractSpinBox_EditingFinished(this); };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void selectAll() { callbackQAbstractSpinBox_SelectAll(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void stepDown() { callbackQAbstractSpinBox_StepDown(this); };
	void stepUp() { callbackQAbstractSpinBox_StepUp(this); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QTimeEdit*)
Q_DECLARE_METATYPE(MyQTimeEdit*)

int QTimeEdit_QTimeEdit_QRegisterMetaType(){qRegisterMetaType<QTimeEdit*>(); return qRegisterMetaType<MyQTimeEdit*>();}

void* QTimeEdit_NewQTimeEdit(void* parent)
{
		return new MyQTimeEdit(static_cast<QWidget*>(parent));
}

void* QTimeEdit_NewQTimeEdit2(void* ti, void* parent)
{
		return new MyQTimeEdit(*static_cast<QTime*>(ti), static_cast<QWidget*>(parent));
}

void QTimeEdit_DestroyQTimeEdit(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->~QTimeEdit();
}

void QTimeEdit_DestroyQTimeEditDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQToolBar: public QToolBar
{
public:
	MyQToolBar(const QString &title, QWidget *parent = Q_NULLPTR) : QToolBar(title, parent) {QToolBar_QToolBar_QRegisterMetaType();};
	MyQToolBar(QWidget *parent = Q_NULLPTR) : QToolBar(parent) {QToolBar_QToolBar_QRegisterMetaType();};
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void Signal_ActionTriggered(QAction * action) { callbackQToolBar_ActionTriggered(this, action); };
	void Signal_AllowedAreasChanged(Qt::ToolBarAreas allowedAreas) { callbackQToolBar_AllowedAreasChanged(this, allowedAreas); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void Signal_IconSizeChanged(const QSize & iconSize) { callbackQToolBar_IconSizeChanged(this, const_cast<QSize*>(&iconSize)); };
	void Signal_MovableChanged(bool movable) { callbackQToolBar_MovableChanged(this, movable); };
	void Signal_OrientationChanged(Qt::Orientation orientation) { callbackQToolBar_OrientationChanged(this, orientation); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void setIconSize(const QSize & iconSize) { callbackQToolBar_SetIconSize(this, const_cast<QSize*>(&iconSize)); };
	void setToolButtonStyle(Qt::ToolButtonStyle toolButtonStyle) { callbackQToolBar_SetToolButtonStyle(this, toolButtonStyle); };
	void Signal_ToolButtonStyleChanged(Qt::ToolButtonStyle toolButtonStyle) { callbackQToolBar_ToolButtonStyleChanged(this, toolButtonStyle); };
	void Signal_TopLevelChanged(bool topLevel) { callbackQToolBar_TopLevelChanged(this, topLevel); };
	void Signal_VisibilityChanged(bool visible) { callbackQToolBar_VisibilityChanged(this, visible); };
	 ~MyQToolBar() { callbackQToolBar_DestroyQToolBar(this); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QToolBar*)
Q_DECLARE_METATYPE(MyQToolBar*)

int QToolBar_QToolBar_QRegisterMetaType(){qRegisterMetaType<QToolBar*>(); return qRegisterMetaType<MyQToolBar*>();}

void* QToolBar_NewQToolBar(struct QtWidgets_PackedString title, void* parent)
{
		return new MyQToolBar(QString::fromUtf8(title.data, title.len), static_cast<QWidget*>(parent));
}

void* QToolBar_NewQToolBar2(void* parent)
{
		return new MyQToolBar(static_cast<QWidget*>(parent));
}

void* QToolBar_ActionAt(void* ptr, void* p)
{
	return static_cast<QToolBar*>(ptr)->actionAt(*static_cast<QPoint*>(p));
}

void* QToolBar_ActionAt2(void* ptr, int x, int y)
{
	return static_cast<QToolBar*>(ptr)->actionAt(x, y);
}

void QToolBar_ConnectActionTriggered(void* ptr, long long t)
{
	QObject::connect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(QAction *)>(&QToolBar::actionTriggered), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(QAction *)>(&MyQToolBar::Signal_ActionTriggered), static_cast<Qt::ConnectionType>(t));
}

void QToolBar_DisconnectActionTriggered(void* ptr)
{
	QObject::disconnect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(QAction *)>(&QToolBar::actionTriggered), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(QAction *)>(&MyQToolBar::Signal_ActionTriggered));
}

void QToolBar_ActionTriggered(void* ptr, void* action)
{
	static_cast<QToolBar*>(ptr)->actionTriggered(static_cast<QAction*>(action));
}

void* QToolBar_AddAction(void* ptr, struct QtWidgets_PackedString text)
{
	return static_cast<QToolBar*>(ptr)->addAction(QString::fromUtf8(text.data, text.len));
}

void* QToolBar_AddAction2(void* ptr, void* icon, struct QtWidgets_PackedString text)
{
	return static_cast<QToolBar*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len));
}

void* QToolBar_AddAction3(void* ptr, struct QtWidgets_PackedString text, void* receiver, char* member)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(receiver))) {
		return static_cast<QToolBar*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsObject*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(receiver))) {
		return static_cast<QToolBar*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsWidget*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(receiver))) {
		return static_cast<QToolBar*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QLayout*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(receiver))) {
		return static_cast<QToolBar*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(receiver), const_cast<const char*>(member));
	} else {
		return static_cast<QToolBar*>(ptr)->addAction(QString::fromUtf8(text.data, text.len), static_cast<QObject*>(receiver), const_cast<const char*>(member));
	}
}

void* QToolBar_AddAction4(void* ptr, void* icon, struct QtWidgets_PackedString text, void* receiver, char* member)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(receiver))) {
		return static_cast<QToolBar*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QGraphicsObject*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(receiver))) {
		return static_cast<QToolBar*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QGraphicsWidget*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(receiver))) {
		return static_cast<QToolBar*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QLayout*>(receiver), const_cast<const char*>(member));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(receiver))) {
		return static_cast<QToolBar*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(receiver), const_cast<const char*>(member));
	} else {
		return static_cast<QToolBar*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len), static_cast<QObject*>(receiver), const_cast<const char*>(member));
	}
}

void* QToolBar_AddSeparator(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->addSeparator();
}

void* QToolBar_AddWidget(void* ptr, void* widget)
{
		return static_cast<QToolBar*>(ptr)->addWidget(static_cast<QWidget*>(widget));
}

long long QToolBar_AllowedAreas(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->allowedAreas();
}

void QToolBar_ConnectAllowedAreasChanged(void* ptr, long long t)
{
	qRegisterMetaType<Qt::ToolBarAreas>();
	QObject::connect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(Qt::ToolBarAreas)>(&QToolBar::allowedAreasChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(Qt::ToolBarAreas)>(&MyQToolBar::Signal_AllowedAreasChanged), static_cast<Qt::ConnectionType>(t));
}

void QToolBar_DisconnectAllowedAreasChanged(void* ptr)
{
	QObject::disconnect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(Qt::ToolBarAreas)>(&QToolBar::allowedAreasChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(Qt::ToolBarAreas)>(&MyQToolBar::Signal_AllowedAreasChanged));
}

void QToolBar_AllowedAreasChanged(void* ptr, long long allowedAreas)
{
	static_cast<QToolBar*>(ptr)->allowedAreasChanged(static_cast<Qt::ToolBarArea>(allowedAreas));
}

void QToolBar_Clear(void* ptr)
{
	static_cast<QToolBar*>(ptr)->clear();
}

void* QToolBar_IconSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolBar*>(ptr)->iconSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QToolBar_ConnectIconSizeChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(const QSize &)>(&QToolBar::iconSizeChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(const QSize &)>(&MyQToolBar::Signal_IconSizeChanged), static_cast<Qt::ConnectionType>(t));
}

void QToolBar_DisconnectIconSizeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(const QSize &)>(&QToolBar::iconSizeChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(const QSize &)>(&MyQToolBar::Signal_IconSizeChanged));
}

void QToolBar_IconSizeChanged(void* ptr, void* iconSize)
{
	static_cast<QToolBar*>(ptr)->iconSizeChanged(*static_cast<QSize*>(iconSize));
}

void* QToolBar_InsertSeparator(void* ptr, void* before)
{
	return static_cast<QToolBar*>(ptr)->insertSeparator(static_cast<QAction*>(before));
}

void* QToolBar_InsertWidget(void* ptr, void* before, void* widget)
{
		return static_cast<QToolBar*>(ptr)->insertWidget(static_cast<QAction*>(before), static_cast<QWidget*>(widget));
}

char QToolBar_IsAreaAllowed(void* ptr, long long area)
{
	return static_cast<QToolBar*>(ptr)->isAreaAllowed(static_cast<Qt::ToolBarArea>(area));
}

char QToolBar_IsFloatable(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->isFloatable();
}

char QToolBar_IsFloating(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->isFloating();
}

char QToolBar_IsMovable(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->isMovable();
}

void QToolBar_ConnectMovableChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(bool)>(&QToolBar::movableChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(bool)>(&MyQToolBar::Signal_MovableChanged), static_cast<Qt::ConnectionType>(t));
}

void QToolBar_DisconnectMovableChanged(void* ptr)
{
	QObject::disconnect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(bool)>(&QToolBar::movableChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(bool)>(&MyQToolBar::Signal_MovableChanged));
}

void QToolBar_MovableChanged(void* ptr, char movable)
{
	static_cast<QToolBar*>(ptr)->movableChanged(movable != 0);
}

long long QToolBar_Orientation(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->orientation();
}

void QToolBar_ConnectOrientationChanged(void* ptr, long long t)
{
	qRegisterMetaType<Qt::Orientation>();
	QObject::connect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(Qt::Orientation)>(&QToolBar::orientationChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(Qt::Orientation)>(&MyQToolBar::Signal_OrientationChanged), static_cast<Qt::ConnectionType>(t));
}

void QToolBar_DisconnectOrientationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(Qt::Orientation)>(&QToolBar::orientationChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(Qt::Orientation)>(&MyQToolBar::Signal_OrientationChanged));
}

void QToolBar_OrientationChanged(void* ptr, long long orientation)
{
	static_cast<QToolBar*>(ptr)->orientationChanged(static_cast<Qt::Orientation>(orientation));
}

void QToolBar_SetAllowedAreas(void* ptr, long long areas)
{
	static_cast<QToolBar*>(ptr)->setAllowedAreas(static_cast<Qt::ToolBarArea>(areas));
}

void QToolBar_SetFloatable(void* ptr, char floatable)
{
	static_cast<QToolBar*>(ptr)->setFloatable(floatable != 0);
}

void QToolBar_SetIconSize(void* ptr, void* iconSize)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setIconSize", Q_ARG(const QSize, *static_cast<QSize*>(iconSize)));
}

void QToolBar_SetIconSizeDefault(void* ptr, void* iconSize)
{
		static_cast<QToolBar*>(ptr)->QToolBar::setIconSize(*static_cast<QSize*>(iconSize));
}

void QToolBar_SetMovable(void* ptr, char movable)
{
	static_cast<QToolBar*>(ptr)->setMovable(movable != 0);
}

void QToolBar_SetOrientation(void* ptr, long long orientation)
{
	static_cast<QToolBar*>(ptr)->setOrientation(static_cast<Qt::Orientation>(orientation));
}

void QToolBar_SetToolButtonStyle(void* ptr, long long toolButtonStyle)
{
	qRegisterMetaType<Qt::ToolButtonStyle>();
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setToolButtonStyle", Q_ARG(Qt::ToolButtonStyle, static_cast<Qt::ToolButtonStyle>(toolButtonStyle)));
}

void QToolBar_SetToolButtonStyleDefault(void* ptr, long long toolButtonStyle)
{
		static_cast<QToolBar*>(ptr)->QToolBar::setToolButtonStyle(static_cast<Qt::ToolButtonStyle>(toolButtonStyle));
}

void* QToolBar_ToggleViewAction(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->toggleViewAction();
}

long long QToolBar_ToolButtonStyle(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->toolButtonStyle();
}

void QToolBar_ConnectToolButtonStyleChanged(void* ptr, long long t)
{
	qRegisterMetaType<Qt::ToolButtonStyle>();
	QObject::connect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(Qt::ToolButtonStyle)>(&QToolBar::toolButtonStyleChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(Qt::ToolButtonStyle)>(&MyQToolBar::Signal_ToolButtonStyleChanged), static_cast<Qt::ConnectionType>(t));
}

void QToolBar_DisconnectToolButtonStyleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(Qt::ToolButtonStyle)>(&QToolBar::toolButtonStyleChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(Qt::ToolButtonStyle)>(&MyQToolBar::Signal_ToolButtonStyleChanged));
}

void QToolBar_ToolButtonStyleChanged(void* ptr, long long toolButtonStyle)
{
	static_cast<QToolBar*>(ptr)->toolButtonStyleChanged(static_cast<Qt::ToolButtonStyle>(toolButtonStyle));
}

void QToolBar_ConnectTopLevelChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(bool)>(&QToolBar::topLevelChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(bool)>(&MyQToolBar::Signal_TopLevelChanged), static_cast<Qt::ConnectionType>(t));
}

void QToolBar_DisconnectTopLevelChanged(void* ptr)
{
	QObject::disconnect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(bool)>(&QToolBar::topLevelChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(bool)>(&MyQToolBar::Signal_TopLevelChanged));
}

void QToolBar_TopLevelChanged(void* ptr, char topLevel)
{
	static_cast<QToolBar*>(ptr)->topLevelChanged(topLevel != 0);
}

void QToolBar_ConnectVisibilityChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(bool)>(&QToolBar::visibilityChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(bool)>(&MyQToolBar::Signal_VisibilityChanged), static_cast<Qt::ConnectionType>(t));
}

void QToolBar_DisconnectVisibilityChanged(void* ptr)
{
	QObject::disconnect(static_cast<QToolBar*>(ptr), static_cast<void (QToolBar::*)(bool)>(&QToolBar::visibilityChanged), static_cast<MyQToolBar*>(ptr), static_cast<void (MyQToolBar::*)(bool)>(&MyQToolBar::Signal_VisibilityChanged));
}

void QToolBar_VisibilityChanged(void* ptr, char visible)
{
	static_cast<QToolBar*>(ptr)->visibilityChanged(visible != 0);
}

void* QToolBar_WidgetForAction(void* ptr, void* action)
{
	return static_cast<QToolBar*>(ptr)->widgetForAction(static_cast<QAction*>(action));
}

void QToolBar_DestroyQToolBar(void* ptr)
{
	static_cast<QToolBar*>(ptr)->~QToolBar();
}

void QToolBar_DestroyQToolBarDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQToolBox: public QToolBox
{
public:
	MyQToolBox(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QToolBox(parent, ff) {QToolBox_QToolBox_QRegisterMetaType();};
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void Signal_CurrentChanged(int index) { callbackQToolBox_CurrentChanged(this, index); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void itemInserted(int index) { callbackQToolBox_ItemInserted(this, index); };
	void itemRemoved(int index) { callbackQToolBox_ItemRemoved(this, index); };
	void setCurrentIndex(int index) { callbackQToolBox_SetCurrentIndex(this, index); };
	void setCurrentWidget(QWidget * widget) { callbackQToolBox_SetCurrentWidget(this, widget); };
	void showEvent(QShowEvent * e) { callbackQWidget_ShowEvent(this, e); };
	 ~MyQToolBox() { callbackQToolBox_DestroyQToolBox(this); };
	void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QToolBox*)
Q_DECLARE_METATYPE(MyQToolBox*)

int QToolBox_QToolBox_QRegisterMetaType(){qRegisterMetaType<QToolBox*>(); return qRegisterMetaType<MyQToolBox*>();}

void* QToolBox_NewQToolBox(void* parent, long long ff)
{
		return new MyQToolBox(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}

int QToolBox_AddItem(void* ptr, void* widget, void* iconSet, struct QtWidgets_PackedString text)
{
		return static_cast<QToolBox*>(ptr)->addItem(static_cast<QWidget*>(widget), *static_cast<QIcon*>(iconSet), QString::fromUtf8(text.data, text.len));
}

int QToolBox_AddItem2(void* ptr, void* w, struct QtWidgets_PackedString text)
{
		return static_cast<QToolBox*>(ptr)->addItem(static_cast<QWidget*>(w), QString::fromUtf8(text.data, text.len));
}

int QToolBox_Count(void* ptr)
{
	return static_cast<QToolBox*>(ptr)->count();
}

void QToolBox_ConnectCurrentChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QToolBox*>(ptr), static_cast<void (QToolBox::*)(int)>(&QToolBox::currentChanged), static_cast<MyQToolBox*>(ptr), static_cast<void (MyQToolBox::*)(int)>(&MyQToolBox::Signal_CurrentChanged), static_cast<Qt::ConnectionType>(t));
}

void QToolBox_DisconnectCurrentChanged(void* ptr)
{
	QObject::disconnect(static_cast<QToolBox*>(ptr), static_cast<void (QToolBox::*)(int)>(&QToolBox::currentChanged), static_cast<MyQToolBox*>(ptr), static_cast<void (MyQToolBox::*)(int)>(&MyQToolBox::Signal_CurrentChanged));
}

void QToolBox_CurrentChanged(void* ptr, int index)
{
	static_cast<QToolBox*>(ptr)->currentChanged(index);
}

int QToolBox_CurrentIndex(void* ptr)
{
	return static_cast<QToolBox*>(ptr)->currentIndex();
}

void* QToolBox_CurrentWidget(void* ptr)
{
	return static_cast<QToolBox*>(ptr)->currentWidget();
}

int QToolBox_IndexOf(void* ptr, void* widget)
{
		return static_cast<QToolBox*>(ptr)->indexOf(static_cast<QWidget*>(widget));
}

int QToolBox_InsertItem(void* ptr, int index, void* widget, void* icon, struct QtWidgets_PackedString text)
{
		return static_cast<QToolBox*>(ptr)->insertItem(index, static_cast<QWidget*>(widget), *static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len));
}

int QToolBox_InsertItem2(void* ptr, int index, void* widget, struct QtWidgets_PackedString text)
{
		return static_cast<QToolBox*>(ptr)->insertItem(index, static_cast<QWidget*>(widget), QString::fromUtf8(text.data, text.len));
}

char QToolBox_IsItemEnabled(void* ptr, int index)
{
	return static_cast<QToolBox*>(ptr)->isItemEnabled(index);
}

void* QToolBox_ItemIcon(void* ptr, int index)
{
	return new QIcon(static_cast<QToolBox*>(ptr)->itemIcon(index));
}

void QToolBox_ItemInserted(void* ptr, int index)
{
	static_cast<QToolBox*>(ptr)->itemInserted(index);
}

void QToolBox_ItemInsertedDefault(void* ptr, int index)
{
		static_cast<QToolBox*>(ptr)->QToolBox::itemInserted(index);
}

void QToolBox_ItemRemoved(void* ptr, int index)
{
	static_cast<QToolBox*>(ptr)->itemRemoved(index);
}

void QToolBox_ItemRemovedDefault(void* ptr, int index)
{
		static_cast<QToolBox*>(ptr)->QToolBox::itemRemoved(index);
}

struct QtWidgets_PackedString QToolBox_ItemText(void* ptr, int index)
{
	return ({ QByteArray* tbfa329 = new QByteArray(static_cast<QToolBox*>(ptr)->itemText(index).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tbfa329->prepend("WHITESPACE").constData()+10), tbfa329->size()-10, tbfa329 }; });
}

struct QtWidgets_PackedString QToolBox_ItemToolTip(void* ptr, int index)
{
	return ({ QByteArray* ta445d4 = new QByteArray(static_cast<QToolBox*>(ptr)->itemToolTip(index).toUtf8()); QtWidgets_PackedString { const_cast<char*>(ta445d4->prepend("WHITESPACE").constData()+10), ta445d4->size()-10, ta445d4 }; });
}

void QToolBox_RemoveItem(void* ptr, int index)
{
	static_cast<QToolBox*>(ptr)->removeItem(index);
}

void QToolBox_SetCurrentIndex(void* ptr, int index)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setCurrentIndex", Q_ARG(int, index));
}

void QToolBox_SetCurrentIndexDefault(void* ptr, int index)
{
		static_cast<QToolBox*>(ptr)->QToolBox::setCurrentIndex(index);
}

void QToolBox_SetCurrentWidget(void* ptr, void* widget)
{
		QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setCurrentWidget", Q_ARG(QWidget*, static_cast<QWidget*>(widget)));
}

void QToolBox_SetCurrentWidgetDefault(void* ptr, void* widget)
{
		static_cast<QToolBox*>(ptr)->QToolBox::setCurrentWidget(static_cast<QWidget*>(widget));
}

void QToolBox_SetItemEnabled(void* ptr, int index, char enabled)
{
	static_cast<QToolBox*>(ptr)->setItemEnabled(index, enabled != 0);
}

void QToolBox_SetItemIcon(void* ptr, int index, void* icon)
{
	static_cast<QToolBox*>(ptr)->setItemIcon(index, *static_cast<QIcon*>(icon));
}

void QToolBox_SetItemText(void* ptr, int index, struct QtWidgets_PackedString text)
{
	static_cast<QToolBox*>(ptr)->setItemText(index, QString::fromUtf8(text.data, text.len));
}

void QToolBox_SetItemToolTip(void* ptr, int index, struct QtWidgets_PackedString toolTip)
{
	static_cast<QToolBox*>(ptr)->setItemToolTip(index, QString::fromUtf8(toolTip.data, toolTip.len));
}

void* QToolBox_Widget(void* ptr, int index)
{
	return static_cast<QToolBox*>(ptr)->widget(index);
}

void QToolBox_DestroyQToolBox(void* ptr)
{
	static_cast<QToolBox*>(ptr)->~QToolBox();
}

void QToolBox_DestroyQToolBoxDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQToolButton: public QToolButton
{
public:
	MyQToolButton(QWidget *parent = Q_NULLPTR) : QToolButton(parent) {QToolButton_QToolButton_QRegisterMetaType();};
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * e) { callbackQWidget_ChangeEvent(this, e); };
	void enterEvent(QEvent * e) { callbackQWidget_EnterEvent(this, e); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	bool hitButton(const QPoint & pos) const { return callbackQAbstractButton_HitButton(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&pos)) != 0; };
	void leaveEvent(QEvent * e) { callbackQWidget_LeaveEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mousePressEvent(QMouseEvent * e) { callbackQWidget_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	void nextCheckState() { callbackQAbstractButton_NextCheckState(this); };
	void paintEvent(QPaintEvent * event) { callbackQToolButton_PaintEvent(this, event); };
	void setDefaultAction(QAction * action) { callbackQToolButton_SetDefaultAction(this, action); };
	void setToolButtonStyle(Qt::ToolButtonStyle style) { callbackQToolButton_SetToolButtonStyle(this, style); };
	void showMenu() { callbackQToolButton_ShowMenu(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void Signal_Triggered(QAction * action) { callbackQToolButton_Triggered(this, action); };
	 ~MyQToolButton() { callbackQToolButton_DestroyQToolButton(this); };
	void animateClick(int msec) { callbackQAbstractButton_AnimateClick(this, msec); };
	void checkStateSet() { callbackQAbstractButton_CheckStateSet(this); };
	void click() { callbackQAbstractButton_Click(this); };
	void Signal_Clicked(bool checked) { callbackQAbstractButton_Clicked(this, checked); };
	void focusInEvent(QFocusEvent * e) { callbackQWidget_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQWidget_FocusOutEvent(this, e); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQWidget_KeyReleaseEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void Signal_Pressed() { callbackQAbstractButton_Pressed(this); };
	void Signal_Released() { callbackQAbstractButton_Released(this); };
	void setChecked(bool vbo) { callbackQAbstractButton_SetChecked(this, vbo); };
	void setIconSize(const QSize & size) { callbackQAbstractButton_SetIconSize(this, const_cast<QSize*>(&size)); };
	void toggle() { callbackQAbstractButton_Toggle(this); };
	void Signal_Toggled(bool checked) { callbackQAbstractButton_Toggled(this, checked); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QToolButton*)
Q_DECLARE_METATYPE(MyQToolButton*)

int QToolButton_QToolButton_QRegisterMetaType(){qRegisterMetaType<QToolButton*>(); return qRegisterMetaType<MyQToolButton*>();}

void* QToolButton_NewQToolButton(void* parent)
{
		return new MyQToolButton(static_cast<QWidget*>(parent));
}

long long QToolButton_ArrowType(void* ptr)
{
	return static_cast<QToolButton*>(ptr)->arrowType();
}

char QToolButton_AutoRaise(void* ptr)
{
	return static_cast<QToolButton*>(ptr)->autoRaise();
}

void* QToolButton_DefaultAction(void* ptr)
{
	return static_cast<QToolButton*>(ptr)->defaultAction();
}

void QToolButton_InitStyleOption(void* ptr, void* option)
{
	static_cast<QToolButton*>(ptr)->initStyleOption(static_cast<QStyleOptionToolButton*>(option));
}

void* QToolButton_Menu(void* ptr)
{
	return static_cast<QToolButton*>(ptr)->menu();
}

void QToolButton_PaintEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QToolButton_PaintEventDefault(void* ptr, void* event)
{
		static_cast<QToolButton*>(ptr)->QToolButton::paintEvent(static_cast<QPaintEvent*>(event));
}

long long QToolButton_PopupMode(void* ptr)
{
	return static_cast<QToolButton*>(ptr)->popupMode();
}

void QToolButton_SetArrowType(void* ptr, long long ty)
{
	static_cast<QToolButton*>(ptr)->setArrowType(static_cast<Qt::ArrowType>(ty));
}

void QToolButton_SetAutoRaise(void* ptr, char enable)
{
	static_cast<QToolButton*>(ptr)->setAutoRaise(enable != 0);
}

void QToolButton_SetDefaultAction(void* ptr, void* action)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setDefaultAction", Q_ARG(QAction*, static_cast<QAction*>(action)));
}

void QToolButton_SetDefaultActionDefault(void* ptr, void* action)
{
		static_cast<QToolButton*>(ptr)->QToolButton::setDefaultAction(static_cast<QAction*>(action));
}

void QToolButton_SetMenu(void* ptr, void* menu)
{
	static_cast<QToolButton*>(ptr)->setMenu(static_cast<QMenu*>(menu));
}

void QToolButton_SetPopupMode(void* ptr, long long mode)
{
	static_cast<QToolButton*>(ptr)->setPopupMode(static_cast<QToolButton::ToolButtonPopupMode>(mode));
}

void QToolButton_SetToolButtonStyle(void* ptr, long long style)
{
	qRegisterMetaType<Qt::ToolButtonStyle>();
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setToolButtonStyle", Q_ARG(Qt::ToolButtonStyle, static_cast<Qt::ToolButtonStyle>(style)));
}

void QToolButton_SetToolButtonStyleDefault(void* ptr, long long style)
{
		static_cast<QToolButton*>(ptr)->QToolButton::setToolButtonStyle(static_cast<Qt::ToolButtonStyle>(style));
}

void QToolButton_ShowMenu(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "showMenu");
}

void QToolButton_ShowMenuDefault(void* ptr)
{
		static_cast<QToolButton*>(ptr)->QToolButton::showMenu();
}

long long QToolButton_ToolButtonStyle(void* ptr)
{
	return static_cast<QToolButton*>(ptr)->toolButtonStyle();
}

void QToolButton_ConnectTriggered(void* ptr, long long t)
{
	QObject::connect(static_cast<QToolButton*>(ptr), static_cast<void (QToolButton::*)(QAction *)>(&QToolButton::triggered), static_cast<MyQToolButton*>(ptr), static_cast<void (MyQToolButton::*)(QAction *)>(&MyQToolButton::Signal_Triggered), static_cast<Qt::ConnectionType>(t));
}

void QToolButton_DisconnectTriggered(void* ptr)
{
	QObject::disconnect(static_cast<QToolButton*>(ptr), static_cast<void (QToolButton::*)(QAction *)>(&QToolButton::triggered), static_cast<MyQToolButton*>(ptr), static_cast<void (MyQToolButton::*)(QAction *)>(&MyQToolButton::Signal_Triggered));
}

void QToolButton_Triggered(void* ptr, void* action)
{
	static_cast<QToolButton*>(ptr)->triggered(static_cast<QAction*>(action));
}

void QToolButton_DestroyQToolButton(void* ptr)
{
	static_cast<QToolButton*>(ptr)->~QToolButton();
}

void QToolButton_DestroyQToolButtonDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QToolTip_QToolTip_Font()
{
	return new QFont(QToolTip::font());
}

void QToolTip_QToolTip_HideText()
{
	QToolTip::hideText();
}

char QToolTip_QToolTip_IsVisible()
{
	return QToolTip::isVisible();
}

void* QToolTip_QToolTip_Palette()
{
	return new QPalette(QToolTip::palette());
}

void QToolTip_QToolTip_SetFont(void* font)
{
	QToolTip::setFont(*static_cast<QFont*>(font));
}

void QToolTip_QToolTip_SetPalette(void* palette)
{
	QToolTip::setPalette(*static_cast<QPalette*>(palette));
}

void QToolTip_QToolTip_ShowText(void* pos, struct QtWidgets_PackedString text, void* w, void* rect)
{
		QToolTip::showText(*static_cast<QPoint*>(pos), QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(w), *static_cast<QRect*>(rect));
}

void QToolTip_QToolTip_ShowText2(void* pos, struct QtWidgets_PackedString text, void* w)
{
		QToolTip::showText(*static_cast<QPoint*>(pos), QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(w));
}

void QToolTip_QToolTip_ShowText3(void* pos, struct QtWidgets_PackedString text, void* w, void* rect, int msecDisplayTime)
{
		QToolTip::showText(*static_cast<QPoint*>(pos), QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(w), *static_cast<QRect*>(rect), msecDisplayTime);
}

struct QtWidgets_PackedString QToolTip_QToolTip_Text()
{
	return ({ QByteArray* tdd5458 = new QByteArray(QToolTip::text().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tdd5458->prepend("WHITESPACE").constData()+10), tdd5458->size()-10, tdd5458 }; });
}

class MyQTreeView: public QTreeView
{
public:
	MyQTreeView(QWidget *parent = Q_NULLPTR) : QTreeView(parent) {QTreeView_QTreeView_QRegisterMetaType();};
	void collapse(const QModelIndex & index) { callbackQTreeView_Collapse(this, const_cast<QModelIndex*>(&index)); };
	void collapseAll() { callbackQTreeView_CollapseAll(this); };
	void Signal_Collapsed(const QModelIndex & index) { callbackQTreeView_Collapsed(this, const_cast<QModelIndex*>(&index)); };
	void columnCountChanged(int oldCount, int newCount) { callbackQTreeView_ColumnCountChanged(this, oldCount, newCount); };
	void columnMoved() { callbackQTreeView_ColumnMoved(this); };
	void columnResized(int column, int oldSize, int newSize) { callbackQTreeView_ColumnResized(this, column, oldSize, newSize); };
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQTreeView_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	void dataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQTreeView_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void drawBranches(QPainter * painter, const QRect & rect, const QModelIndex & index) const { callbackQTreeView_DrawBranches(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QRect*>(&rect), const_cast<QModelIndex*>(&index)); };
	void drawRow(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQTreeView_DrawRow(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	void expand(const QModelIndex & index) { callbackQTreeView_Expand(this, const_cast<QModelIndex*>(&index)); };
	void expandAll() { callbackQTreeView_ExpandAll(this); };
	void expandRecursively(const QModelIndex & index, int depth) { callbackQTreeView_ExpandRecursively(this, const_cast<QModelIndex*>(&index), depth); };
	void expandToDepth(int depth) { callbackQTreeView_ExpandToDepth(this, depth); };
	void Signal_Expanded(const QModelIndex & index) { callbackQTreeView_Expanded(this, const_cast<QModelIndex*>(&index)); };
	void hideColumn(int column) { callbackQTreeView_HideColumn(this, column); };
	int horizontalOffset() const { return callbackQTreeView_HorizontalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQTreeView_IndexAt(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&point))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQTreeView_IsIndexHidden(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index)) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { QByteArray* t3559d7 = new QByteArray(search.toUtf8()); QtWidgets_PackedString searchPacked = { const_cast<char*>(t3559d7->prepend("WHITESPACE").constData()+10), t3559d7->size()-10, t3559d7 };callbackQAbstractItemView_KeyboardSearch(this, searchPacked); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQTreeView_MoveCursor(this, cursorAction, modifiers)); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void reset() { callbackQTreeView_Reset(this); };
	void resizeColumnToContents(int column) { callbackQTreeView_ResizeColumnToContents(this, column); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQTreeView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQTreeView_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsRemoved(const QModelIndex & parent, int start, int end) { callbackQTreeView_RowsRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQTreeView_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	void selectAll() { callbackQTreeView_SelectAll(this); };
	QList<QModelIndex> selectedIndexes() const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemView_SelectedIndexes(const_cast<void*>(static_cast<const void*>(this)))); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQTreeView_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	void setModel(QAbstractItemModel * model) { callbackQAbstractItemView_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQTreeView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQTreeView_SetSelection(this, const_cast<QRect*>(&rect), command); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQAbstractItemView_SetSelectionModel(this, selectionModel); };
	void showColumn(int column) { callbackQTreeView_ShowColumn(this, column); };
	int sizeHintForColumn(int column) const { return callbackQAbstractItemView_SizeHintForColumn(const_cast<void*>(static_cast<const void*>(this)), column); };
	void sortByColumn(int column, Qt::SortOrder order) { callbackQTreeView_SortByColumn(this, column, order); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	void updateGeometries() { callbackQTreeView_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQTreeView_VerticalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQTreeView_VisualRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQTreeView_VisualRegionForSelection(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&selection))); };
	 ~MyQTreeView() { callbackQTreeView_DestroyQTreeView(this); };
	void Signal_Activated(const QModelIndex & index) { callbackQAbstractItemView_Activated(this, const_cast<QModelIndex*>(&index)); };
	void clearSelection() { callbackQAbstractItemView_ClearSelection(this); };
	void Signal_Clicked(const QModelIndex & index) { callbackQAbstractItemView_Clicked(this, const_cast<QModelIndex*>(&index)); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQAbstractItemView_CommitData(this, editor); };
	void Signal_DoubleClicked(const QModelIndex & index) { callbackQAbstractItemView_DoubleClicked(this, const_cast<QModelIndex*>(&index)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQAbstractItemView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQAbstractItemView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQAbstractItemView_EditorDestroyed(this, editor); };
	void Signal_Entered(const QModelIndex & index) { callbackQAbstractItemView_Entered(this, const_cast<QModelIndex*>(&index)); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQWidget_EventFilter(this, object, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void Signal_IconSizeChanged(const QSize & size) { callbackQAbstractItemView_IconSizeChanged(this, const_cast<QSize*>(&size)); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void Signal_Pressed(const QModelIndex & index) { callbackQAbstractItemView_Pressed(this, const_cast<QModelIndex*>(&index)); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void scrollToBottom() { callbackQAbstractItemView_ScrollToBottom(this); };
	void scrollToTop() { callbackQAbstractItemView_ScrollToTop(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQAbstractItemView_SelectionCommand(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQAbstractItemView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	int sizeHintForRow(int row) const { return callbackQAbstractItemView_SizeHintForRow(const_cast<void*>(static_cast<const void*>(this)), row); };
	void startDrag(Qt::DropActions supportedActions) { callbackQAbstractItemView_StartDrag(this, supportedActions); };
	void update(const QModelIndex & index) { callbackQAbstractItemView_Update(this, const_cast<QModelIndex*>(&index)); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQAbstractItemView_ViewOptions(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ViewportEntered() { callbackQAbstractItemView_ViewportEntered(this); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QTreeView*)
Q_DECLARE_METATYPE(MyQTreeView*)

int QTreeView_QTreeView_QRegisterMetaType(){qRegisterMetaType<QTreeView*>(); return qRegisterMetaType<MyQTreeView*>();}

void* QTreeView_NewQTreeView(void* parent)
{
		return new MyQTreeView(static_cast<QWidget*>(parent));
}

char QTreeView_AllColumnsShowFocus(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->allColumnsShowFocus();
}

int QTreeView_AutoExpandDelay(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->autoExpandDelay();
}

void QTreeView_Collapse(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "collapse", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTreeView_CollapseDefault(void* ptr, void* index)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::collapse(*static_cast<QModelIndex*>(index));
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::collapse(*static_cast<QModelIndex*>(index));
	}
}

void QTreeView_CollapseAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "collapseAll");
}

void QTreeView_CollapseAllDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::collapseAll();
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::collapseAll();
	}
}

void QTreeView_ConnectCollapsed(void* ptr, long long t)
{
	QObject::connect(static_cast<QTreeView*>(ptr), static_cast<void (QTreeView::*)(const QModelIndex &)>(&QTreeView::collapsed), static_cast<MyQTreeView*>(ptr), static_cast<void (MyQTreeView::*)(const QModelIndex &)>(&MyQTreeView::Signal_Collapsed), static_cast<Qt::ConnectionType>(t));
}

void QTreeView_DisconnectCollapsed(void* ptr)
{
	QObject::disconnect(static_cast<QTreeView*>(ptr), static_cast<void (QTreeView::*)(const QModelIndex &)>(&QTreeView::collapsed), static_cast<MyQTreeView*>(ptr), static_cast<void (MyQTreeView::*)(const QModelIndex &)>(&MyQTreeView::Signal_Collapsed));
}

void QTreeView_Collapsed(void* ptr, void* index)
{
	static_cast<QTreeView*>(ptr)->collapsed(*static_cast<QModelIndex*>(index));
}

int QTreeView_ColumnAt(void* ptr, int x)
{
	return static_cast<QTreeView*>(ptr)->columnAt(x);
}

void QTreeView_ColumnCountChanged(void* ptr, int oldCount, int newCount)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "columnCountChanged", Q_ARG(int, oldCount), Q_ARG(int, newCount));
}

void QTreeView_ColumnCountChangedDefault(void* ptr, int oldCount, int newCount)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::columnCountChanged(oldCount, newCount);
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::columnCountChanged(oldCount, newCount);
	}
}

void QTreeView_ColumnMoved(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "columnMoved");
}

void QTreeView_ColumnMovedDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::columnMoved();
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::columnMoved();
	}
}

void QTreeView_ColumnResized(void* ptr, int column, int oldSize, int newSize)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "columnResized", Q_ARG(int, column), Q_ARG(int, oldSize), Q_ARG(int, newSize));
}

void QTreeView_ColumnResizedDefault(void* ptr, int column, int oldSize, int newSize)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::columnResized(column, oldSize, newSize);
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::columnResized(column, oldSize, newSize);
	}
}

int QTreeView_ColumnViewportPosition(void* ptr, int column)
{
	return static_cast<QTreeView*>(ptr)->columnViewportPosition(column);
}

int QTreeView_ColumnWidth(void* ptr, int column)
{
	return static_cast<QTreeView*>(ptr)->columnWidth(column);
}

void QTreeView_CurrentChanged(void* ptr, void* current, void* previous)
{
	static_cast<QTreeView*>(ptr)->currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QTreeView_CurrentChangedDefault(void* ptr, void* current, void* previous)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
	}
}

void QTreeView_DataChanged(void* ptr, void* topLeft, void* bottomRight, void* roles)
{
	static_cast<QTreeView*>(ptr)->dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
}

void QTreeView_DataChangedDefault(void* ptr, void* topLeft, void* bottomRight, void* roles)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
	}
}

void QTreeView_DrawBranches(void* ptr, void* painter, void* rect, void* index)
{
	static_cast<QTreeView*>(ptr)->drawBranches(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), *static_cast<QModelIndex*>(index));
}

void QTreeView_DrawBranchesDefault(void* ptr, void* painter, void* rect, void* index)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::drawBranches(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), *static_cast<QModelIndex*>(index));
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::drawBranches(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), *static_cast<QModelIndex*>(index));
	}
}

void QTreeView_DrawRow(void* ptr, void* painter, void* option, void* index)
{
	static_cast<QTreeView*>(ptr)->drawRow(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QTreeView_DrawRowDefault(void* ptr, void* painter, void* option, void* index)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::drawRow(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::drawRow(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
	}
}

void QTreeView_DrawTree(void* ptr, void* painter, void* region)
{
	static_cast<QTreeView*>(ptr)->drawTree(static_cast<QPainter*>(painter), *static_cast<QRegion*>(region));
}

void QTreeView_Expand(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "expand", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTreeView_ExpandDefault(void* ptr, void* index)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::expand(*static_cast<QModelIndex*>(index));
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::expand(*static_cast<QModelIndex*>(index));
	}
}

void QTreeView_ExpandAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "expandAll");
}

void QTreeView_ExpandAllDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::expandAll();
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::expandAll();
	}
}

void QTreeView_ExpandRecursively(void* ptr, void* index, int depth)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "expandRecursively", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(index)), Q_ARG(int, depth));
}

void QTreeView_ExpandRecursivelyDefault(void* ptr, void* index, int depth)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::expandRecursively(*static_cast<QModelIndex*>(index), depth);
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::expandRecursively(*static_cast<QModelIndex*>(index), depth);
	}
}

void QTreeView_ExpandToDepth(void* ptr, int depth)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "expandToDepth", Q_ARG(int, depth));
}

void QTreeView_ExpandToDepthDefault(void* ptr, int depth)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::expandToDepth(depth);
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::expandToDepth(depth);
	}
}

void QTreeView_ConnectExpanded(void* ptr, long long t)
{
	QObject::connect(static_cast<QTreeView*>(ptr), static_cast<void (QTreeView::*)(const QModelIndex &)>(&QTreeView::expanded), static_cast<MyQTreeView*>(ptr), static_cast<void (MyQTreeView::*)(const QModelIndex &)>(&MyQTreeView::Signal_Expanded), static_cast<Qt::ConnectionType>(t));
}

void QTreeView_DisconnectExpanded(void* ptr)
{
	QObject::disconnect(static_cast<QTreeView*>(ptr), static_cast<void (QTreeView::*)(const QModelIndex &)>(&QTreeView::expanded), static_cast<MyQTreeView*>(ptr), static_cast<void (MyQTreeView::*)(const QModelIndex &)>(&MyQTreeView::Signal_Expanded));
}

void QTreeView_Expanded(void* ptr, void* index)
{
	static_cast<QTreeView*>(ptr)->expanded(*static_cast<QModelIndex*>(index));
}

char QTreeView_ExpandsOnDoubleClick(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->expandsOnDoubleClick();
}

void* QTreeView_Header(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->header();
}

void QTreeView_HideColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "hideColumn", Q_ARG(int, column));
}

void QTreeView_HideColumnDefault(void* ptr, int column)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::hideColumn(column);
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::hideColumn(column);
	}
}

int QTreeView_HorizontalOffset(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->horizontalOffset();
}

int QTreeView_HorizontalOffsetDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::horizontalOffset();
	} else {
		return static_cast<QTreeView*>(ptr)->QTreeView::horizontalOffset();
	}
}

int QTreeView_Indentation(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->indentation();
}

void* QTreeView_IndexAbove(void* ptr, void* index)
{
	return new QModelIndex(static_cast<QTreeView*>(ptr)->indexAbove(*static_cast<QModelIndex*>(index)));
}

void* QTreeView_IndexAt(void* ptr, void* point)
{
	return new QModelIndex(static_cast<QTreeView*>(ptr)->indexAt(*static_cast<QPoint*>(point)));
}

void* QTreeView_IndexAtDefault(void* ptr, void* point)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return new QModelIndex(static_cast<QTreeWidget*>(ptr)->QTreeWidget::indexAt(*static_cast<QPoint*>(point)));
	} else {
		return new QModelIndex(static_cast<QTreeView*>(ptr)->QTreeView::indexAt(*static_cast<QPoint*>(point)));
	}
}

void* QTreeView_IndexBelow(void* ptr, void* index)
{
	return new QModelIndex(static_cast<QTreeView*>(ptr)->indexBelow(*static_cast<QModelIndex*>(index)));
}

int QTreeView_IndexRowSizeHint(void* ptr, void* index)
{
	return static_cast<QTreeView*>(ptr)->indexRowSizeHint(*static_cast<QModelIndex*>(index));
}

char QTreeView_IsAnimated(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->isAnimated();
}

char QTreeView_IsColumnHidden(void* ptr, int column)
{
	return static_cast<QTreeView*>(ptr)->isColumnHidden(column);
}

char QTreeView_IsExpanded(void* ptr, void* index)
{
	return static_cast<QTreeView*>(ptr)->isExpanded(*static_cast<QModelIndex*>(index));
}

char QTreeView_IsFirstColumnSpanned(void* ptr, int row, void* parent)
{
	return static_cast<QTreeView*>(ptr)->isFirstColumnSpanned(row, *static_cast<QModelIndex*>(parent));
}

char QTreeView_IsHeaderHidden(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->isHeaderHidden();
}

char QTreeView_IsIndexHidden(void* ptr, void* index)
{
	return static_cast<QTreeView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}

char QTreeView_IsIndexHiddenDefault(void* ptr, void* index)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::isIndexHidden(*static_cast<QModelIndex*>(index));
	} else {
		return static_cast<QTreeView*>(ptr)->QTreeView::isIndexHidden(*static_cast<QModelIndex*>(index));
	}
}

char QTreeView_IsRowHidden(void* ptr, int row, void* parent)
{
	return static_cast<QTreeView*>(ptr)->isRowHidden(row, *static_cast<QModelIndex*>(parent));
}

char QTreeView_IsSortingEnabled(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->isSortingEnabled();
}

char QTreeView_ItemsExpandable(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->itemsExpandable();
}

void* QTreeView_MoveCursor(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QTreeView*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void* QTreeView_MoveCursorDefault(void* ptr, long long cursorAction, long long modifiers)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return new QModelIndex(static_cast<QTreeWidget*>(ptr)->QTreeWidget::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
	} else {
		return new QModelIndex(static_cast<QTreeView*>(ptr)->QTreeView::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
	}
}

void QTreeView_Reset(void* ptr)
{
	static_cast<QTreeView*>(ptr)->reset();
}

void QTreeView_ResetDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::reset();
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::reset();
	}
}

void QTreeView_ResetIndentation(void* ptr)
{
	static_cast<QTreeView*>(ptr)->resetIndentation();
}

void QTreeView_ResizeColumnToContents(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "resizeColumnToContents", Q_ARG(int, column));
}

void QTreeView_ResizeColumnToContentsDefault(void* ptr, int column)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::resizeColumnToContents(column);
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::resizeColumnToContents(column);
	}
}

char QTreeView_RootIsDecorated(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->rootIsDecorated();
}

int QTreeView_RowHeight(void* ptr, void* index)
{
	return static_cast<QTreeView*>(ptr)->rowHeight(*static_cast<QModelIndex*>(index));
}

void QTreeView_RowsAboutToBeRemoved(void* ptr, void* parent, int start, int end)
{
	static_cast<QTreeView*>(ptr)->rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
}

void QTreeView_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
	}
}

void QTreeView_RowsInserted(void* ptr, void* parent, int start, int end)
{
	static_cast<QTreeView*>(ptr)->rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
}

void QTreeView_RowsInsertedDefault(void* ptr, void* parent, int start, int end)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
	}
}

void QTreeView_RowsRemoved(void* ptr, void* parent, int start, int end)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "rowsRemoved", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
}

void QTreeView_RowsRemovedDefault(void* ptr, void* parent, int start, int end)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::rowsRemoved(*static_cast<QModelIndex*>(parent), start, end);
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::rowsRemoved(*static_cast<QModelIndex*>(parent), start, end);
	}
}

void QTreeView_ScrollTo(void* ptr, void* index, long long hint)
{
	static_cast<QTreeView*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QTreeView_ScrollToDefault(void* ptr, void* index, long long hint)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
	}
}

void QTreeView_SelectAll(void* ptr)
{
	static_cast<QTreeView*>(ptr)->selectAll();
}

void QTreeView_SelectAllDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::selectAll();
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::selectAll();
	}
}

void QTreeView_SelectionChanged(void* ptr, void* selected, void* deselected)
{
	static_cast<QTreeView*>(ptr)->selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

void QTreeView_SelectionChangedDefault(void* ptr, void* selected, void* deselected)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
	}
}

void QTreeView_SetAllColumnsShowFocus(void* ptr, char enable)
{
	static_cast<QTreeView*>(ptr)->setAllColumnsShowFocus(enable != 0);
}

void QTreeView_SetAnimated(void* ptr, char enable)
{
	static_cast<QTreeView*>(ptr)->setAnimated(enable != 0);
}

void QTreeView_SetAutoExpandDelay(void* ptr, int delay)
{
	static_cast<QTreeView*>(ptr)->setAutoExpandDelay(delay);
}

void QTreeView_SetColumnHidden(void* ptr, int column, char hide)
{
	static_cast<QTreeView*>(ptr)->setColumnHidden(column, hide != 0);
}

void QTreeView_SetColumnWidth(void* ptr, int column, int width)
{
	static_cast<QTreeView*>(ptr)->setColumnWidth(column, width);
}

void QTreeView_SetExpanded(void* ptr, void* index, char expanded)
{
	static_cast<QTreeView*>(ptr)->setExpanded(*static_cast<QModelIndex*>(index), expanded != 0);
}

void QTreeView_SetExpandsOnDoubleClick(void* ptr, char enable)
{
	static_cast<QTreeView*>(ptr)->setExpandsOnDoubleClick(enable != 0);
}

void QTreeView_SetFirstColumnSpanned(void* ptr, int row, void* parent, char span)
{
	static_cast<QTreeView*>(ptr)->setFirstColumnSpanned(row, *static_cast<QModelIndex*>(parent), span != 0);
}

void QTreeView_SetHeader(void* ptr, void* header)
{
	static_cast<QTreeView*>(ptr)->setHeader(static_cast<QHeaderView*>(header));
}

void QTreeView_SetHeaderHidden(void* ptr, char hide)
{
	static_cast<QTreeView*>(ptr)->setHeaderHidden(hide != 0);
}

void QTreeView_SetIndentation(void* ptr, int i)
{
	static_cast<QTreeView*>(ptr)->setIndentation(i);
}

void QTreeView_SetItemsExpandable(void* ptr, char enable)
{
	static_cast<QTreeView*>(ptr)->setItemsExpandable(enable != 0);
}

void QTreeView_SetRootIndex(void* ptr, void* index)
{
	static_cast<QTreeView*>(ptr)->setRootIndex(*static_cast<QModelIndex*>(index));
}

void QTreeView_SetRootIndexDefault(void* ptr, void* index)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setRootIndex(*static_cast<QModelIndex*>(index));
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::setRootIndex(*static_cast<QModelIndex*>(index));
	}
}

void QTreeView_SetRootIsDecorated(void* ptr, char show)
{
	static_cast<QTreeView*>(ptr)->setRootIsDecorated(show != 0);
}

void QTreeView_SetRowHidden(void* ptr, int row, void* parent, char hide)
{
	static_cast<QTreeView*>(ptr)->setRowHidden(row, *static_cast<QModelIndex*>(parent), hide != 0);
}

void QTreeView_SetSelection(void* ptr, void* rect, long long command)
{
	static_cast<QTreeView*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QTreeView_SetSelectionDefault(void* ptr, void* rect, long long command)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
	}
}

void QTreeView_SetSortingEnabled(void* ptr, char enable)
{
	static_cast<QTreeView*>(ptr)->setSortingEnabled(enable != 0);
}

void QTreeView_SetTreePosition(void* ptr, int index)
{
	static_cast<QTreeView*>(ptr)->setTreePosition(index);
}

void QTreeView_SetUniformRowHeights(void* ptr, char uniform)
{
	static_cast<QTreeView*>(ptr)->setUniformRowHeights(uniform != 0);
}

void QTreeView_SetWordWrap(void* ptr, char on)
{
	static_cast<QTreeView*>(ptr)->setWordWrap(on != 0);
}

void QTreeView_ShowColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "showColumn", Q_ARG(int, column));
}

void QTreeView_ShowColumnDefault(void* ptr, int column)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::showColumn(column);
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::showColumn(column);
	}
}

void QTreeView_SortByColumn(void* ptr, int column, long long order)
{
	qRegisterMetaType<Qt::SortOrder>();
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "sortByColumn", Q_ARG(int, column), Q_ARG(Qt::SortOrder, static_cast<Qt::SortOrder>(order)));
}

void QTreeView_SortByColumnDefault(void* ptr, int column, long long order)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::sortByColumn(column, static_cast<Qt::SortOrder>(order));
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::sortByColumn(column, static_cast<Qt::SortOrder>(order));
	}
}

int QTreeView_TreePosition(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->treePosition();
}

char QTreeView_UniformRowHeights(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->uniformRowHeights();
}

void QTreeView_UpdateGeometries(void* ptr)
{
	static_cast<QTreeView*>(ptr)->updateGeometries();
}

void QTreeView_UpdateGeometriesDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::updateGeometries();
	} else {
		static_cast<QTreeView*>(ptr)->QTreeView::updateGeometries();
	}
}

int QTreeView_VerticalOffset(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->verticalOffset();
}

int QTreeView_VerticalOffsetDefault(void* ptr)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::verticalOffset();
	} else {
		return static_cast<QTreeView*>(ptr)->QTreeView::verticalOffset();
	}
}

void* QTreeView_VisualRect(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QTreeView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QTreeView_VisualRectDefault(void* ptr, void* index)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QTreeWidget*>(ptr)->QTreeWidget::visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRect tmpValue = static_cast<QTreeView*>(ptr)->QTreeView::visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QTreeView_VisualRegionForSelection(void* ptr, void* selection)
{
	return new QRegion(static_cast<QTreeView*>(ptr)->visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void* QTreeView_VisualRegionForSelectionDefault(void* ptr, void* selection)
{
	if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return new QRegion(static_cast<QTreeWidget*>(ptr)->QTreeWidget::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
	} else {
		return new QRegion(static_cast<QTreeView*>(ptr)->QTreeView::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
	}
}

char QTreeView_WordWrap(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->wordWrap();
}

void QTreeView_DestroyQTreeView(void* ptr)
{
	static_cast<QTreeView*>(ptr)->~QTreeView();
}

void QTreeView_DestroyQTreeViewDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQTreeWidget: public QTreeWidget
{
public:
	MyQTreeWidget(QWidget *parent = Q_NULLPTR) : QTreeWidget(parent) {QTreeWidget_QTreeWidget_QRegisterMetaType();};
	void clear() { callbackQTreeWidget_Clear(this); };
	void collapseItem(const QTreeWidgetItem * item) { callbackQTreeWidget_CollapseItem(this, const_cast<QTreeWidgetItem*>(item)); };
	void Signal_CurrentItemChanged(QTreeWidgetItem * current, QTreeWidgetItem * previous) { callbackQTreeWidget_CurrentItemChanged(this, current, previous); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	bool dropMimeData(QTreeWidgetItem * parent, int index, const QMimeData * data, Qt::DropAction action) { return callbackQTreeWidget_DropMimeData(this, parent, index, const_cast<QMimeData*>(data), action) != 0; };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	void expandItem(const QTreeWidgetItem * item) { callbackQTreeWidget_ExpandItem(this, const_cast<QTreeWidgetItem*>(item)); };
	void Signal_ItemActivated(QTreeWidgetItem * item, int column) { callbackQTreeWidget_ItemActivated(this, item, column); };
	void Signal_ItemChanged(QTreeWidgetItem * item, int column) { callbackQTreeWidget_ItemChanged(this, item, column); };
	void Signal_ItemClicked(QTreeWidgetItem * item, int column) { callbackQTreeWidget_ItemClicked(this, item, column); };
	void Signal_ItemCollapsed(QTreeWidgetItem * item) { callbackQTreeWidget_ItemCollapsed(this, item); };
	void Signal_ItemDoubleClicked(QTreeWidgetItem * item, int column) { callbackQTreeWidget_ItemDoubleClicked(this, item, column); };
	void Signal_ItemEntered(QTreeWidgetItem * item, int column) { callbackQTreeWidget_ItemEntered(this, item, column); };
	void Signal_ItemExpanded(QTreeWidgetItem * item) { callbackQTreeWidget_ItemExpanded(this, item); };
	void Signal_ItemPressed(QTreeWidgetItem * item, int column) { callbackQTreeWidget_ItemPressed(this, item, column); };
	void Signal_ItemSelectionChanged() { callbackQTreeWidget_ItemSelectionChanged(this); };
	QMimeData * mimeData(const QList<QTreeWidgetItem *> items) const { return static_cast<QMimeData*>(callbackQTreeWidget_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QTreeWidgetItem *>* tmpValue7316c8 = new QList<QTreeWidgetItem *>(items); QtWidgets_PackedList { tmpValue7316c8, tmpValue7316c8->size() }; }))); };
	QStringList mimeTypes() const { return ({ QtWidgets_PackedString tempVal = callbackQTreeWidget_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
	void scrollToItem(const QTreeWidgetItem * item, QAbstractItemView::ScrollHint hint) { callbackQTreeWidget_ScrollToItem(this, const_cast<QTreeWidgetItem*>(item), hint); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQAbstractItemView_SetSelectionModel(this, selectionModel); };
	Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQTreeWidget_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
	 ~MyQTreeWidget() { callbackQTreeWidget_DestroyQTreeWidget(this); };
	void collapse(const QModelIndex & index) { callbackQTreeView_Collapse(this, const_cast<QModelIndex*>(&index)); };
	void collapseAll() { callbackQTreeView_CollapseAll(this); };
	void Signal_Collapsed(const QModelIndex & index) { callbackQTreeView_Collapsed(this, const_cast<QModelIndex*>(&index)); };
	void columnCountChanged(int oldCount, int newCount) { callbackQTreeView_ColumnCountChanged(this, oldCount, newCount); };
	void columnMoved() { callbackQTreeView_ColumnMoved(this); };
	void columnResized(int column, int oldSize, int newSize) { callbackQTreeView_ColumnResized(this, column, oldSize, newSize); };
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQTreeView_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	void dataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQTreeView_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void drawBranches(QPainter * painter, const QRect & rect, const QModelIndex & index) const { callbackQTreeView_DrawBranches(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QRect*>(&rect), const_cast<QModelIndex*>(&index)); };
	void drawRow(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQTreeView_DrawRow(const_cast<void*>(static_cast<const void*>(this)), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	void expand(const QModelIndex & index) { callbackQTreeView_Expand(this, const_cast<QModelIndex*>(&index)); };
	void expandAll() { callbackQTreeView_ExpandAll(this); };
	void expandRecursively(const QModelIndex & index, int depth) { callbackQTreeView_ExpandRecursively(this, const_cast<QModelIndex*>(&index), depth); };
	void expandToDepth(int depth) { callbackQTreeView_ExpandToDepth(this, depth); };
	void Signal_Expanded(const QModelIndex & index) { callbackQTreeView_Expanded(this, const_cast<QModelIndex*>(&index)); };
	void hideColumn(int column) { callbackQTreeView_HideColumn(this, column); };
	int horizontalOffset() const { return callbackQTreeView_HorizontalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQTreeView_IndexAt(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&point))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQTreeView_IsIndexHidden(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index)) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { QByteArray* t3559d7 = new QByteArray(search.toUtf8()); QtWidgets_PackedString searchPacked = { const_cast<char*>(t3559d7->prepend("WHITESPACE").constData()+10), t3559d7->size()-10, t3559d7 };callbackQAbstractItemView_KeyboardSearch(this, searchPacked); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQTreeView_MoveCursor(this, cursorAction, modifiers)); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void reset() { callbackQTreeView_Reset(this); };
	void resizeColumnToContents(int column) { callbackQTreeView_ResizeColumnToContents(this, column); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQTreeView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQTreeView_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsRemoved(const QModelIndex & parent, int start, int end) { callbackQTreeView_RowsRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQTreeView_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	void selectAll() { callbackQTreeView_SelectAll(this); };
	QList<QModelIndex> selectedIndexes() const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemView_SelectedIndexes(const_cast<void*>(static_cast<const void*>(this)))); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQTreeView_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	void setModel(QAbstractItemModel * model) { callbackQAbstractItemView_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQTreeView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQTreeView_SetSelection(this, const_cast<QRect*>(&rect), command); };
	void showColumn(int column) { callbackQTreeView_ShowColumn(this, column); };
	int sizeHintForColumn(int column) const { return callbackQAbstractItemView_SizeHintForColumn(const_cast<void*>(static_cast<const void*>(this)), column); };
	void sortByColumn(int column, Qt::SortOrder order) { callbackQTreeView_SortByColumn(this, column, order); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	void updateGeometries() { callbackQTreeView_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQTreeView_VerticalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQTreeView_VisualRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQTreeView_VisualRegionForSelection(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&selection))); };
	void Signal_Activated(const QModelIndex & index) { callbackQAbstractItemView_Activated(this, const_cast<QModelIndex*>(&index)); };
	void clearSelection() { callbackQAbstractItemView_ClearSelection(this); };
	void Signal_Clicked(const QModelIndex & index) { callbackQAbstractItemView_Clicked(this, const_cast<QModelIndex*>(&index)); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQAbstractItemView_CommitData(this, editor); };
	void Signal_DoubleClicked(const QModelIndex & index) { callbackQAbstractItemView_DoubleClicked(this, const_cast<QModelIndex*>(&index)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQAbstractItemView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQAbstractItemView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQAbstractItemView_EditorDestroyed(this, editor); };
	void Signal_Entered(const QModelIndex & index) { callbackQAbstractItemView_Entered(this, const_cast<QModelIndex*>(&index)); };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQWidget_EventFilter(this, object, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void Signal_IconSizeChanged(const QSize & size) { callbackQAbstractItemView_IconSizeChanged(this, const_cast<QSize*>(&size)); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void Signal_Pressed(const QModelIndex & index) { callbackQAbstractItemView_Pressed(this, const_cast<QModelIndex*>(&index)); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void scrollToBottom() { callbackQAbstractItemView_ScrollToBottom(this); };
	void scrollToTop() { callbackQAbstractItemView_ScrollToTop(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQAbstractItemView_SelectionCommand(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQAbstractItemView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	int sizeHintForRow(int row) const { return callbackQAbstractItemView_SizeHintForRow(const_cast<void*>(static_cast<const void*>(this)), row); };
	void startDrag(Qt::DropActions supportedActions) { callbackQAbstractItemView_StartDrag(this, supportedActions); };
	void update(const QModelIndex & index) { callbackQAbstractItemView_Update(this, const_cast<QModelIndex*>(&index)); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQAbstractItemView_ViewOptions(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ViewportEntered() { callbackQAbstractItemView_ViewportEntered(this); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QTreeWidget*)
Q_DECLARE_METATYPE(MyQTreeWidget*)

int QTreeWidget_QTreeWidget_QRegisterMetaType(){qRegisterMetaType<QTreeWidget*>(); return qRegisterMetaType<MyQTreeWidget*>();}

void* QTreeWidget_NewQTreeWidget(void* parent)
{
		return new MyQTreeWidget(static_cast<QWidget*>(parent));
}

void QTreeWidget_AddTopLevelItem(void* ptr, void* item)
{
	static_cast<QTreeWidget*>(ptr)->addTopLevelItem(static_cast<QTreeWidgetItem*>(item));
}

void QTreeWidget_AddTopLevelItems(void* ptr, void* items)
{
	static_cast<QTreeWidget*>(ptr)->addTopLevelItems(*static_cast<QList<QTreeWidgetItem *>*>(items));
}

void QTreeWidget_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "clear");
}

void QTreeWidget_ClearDefault(void* ptr)
{
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::clear();
}

void QTreeWidget_ClosePersistentEditor(void* ptr, void* item, int column)
{
	static_cast<QTreeWidget*>(ptr)->closePersistentEditor(static_cast<QTreeWidgetItem*>(item), column);
}

void QTreeWidget_CollapseItem(void* ptr, void* item)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "collapseItem", Q_ARG(const QTreeWidgetItem*, static_cast<QTreeWidgetItem*>(item)));
}

void QTreeWidget_CollapseItemDefault(void* ptr, void* item)
{
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::collapseItem(static_cast<QTreeWidgetItem*>(item));
}

int QTreeWidget_ColumnCount(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->columnCount();
}

int QTreeWidget_CurrentColumn(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->currentColumn();
}

void* QTreeWidget_CurrentItem(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->currentItem();
}

void QTreeWidget_ConnectCurrentItemChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, QTreeWidgetItem *)>(&QTreeWidget::currentItemChanged), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, QTreeWidgetItem *)>(&MyQTreeWidget::Signal_CurrentItemChanged), static_cast<Qt::ConnectionType>(t));
}

void QTreeWidget_DisconnectCurrentItemChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, QTreeWidgetItem *)>(&QTreeWidget::currentItemChanged), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, QTreeWidgetItem *)>(&MyQTreeWidget::Signal_CurrentItemChanged));
}

void QTreeWidget_CurrentItemChanged(void* ptr, void* current, void* previous)
{
	static_cast<QTreeWidget*>(ptr)->currentItemChanged(static_cast<QTreeWidgetItem*>(current), static_cast<QTreeWidgetItem*>(previous));
}

char QTreeWidget_DropMimeData(void* ptr, void* parent, int index, void* data, long long action)
{
	return static_cast<QTreeWidget*>(ptr)->dropMimeData(static_cast<QTreeWidgetItem*>(parent), index, static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action));
}

char QTreeWidget_DropMimeDataDefault(void* ptr, void* parent, int index, void* data, long long action)
{
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::dropMimeData(static_cast<QTreeWidgetItem*>(parent), index, static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action));
}

void QTreeWidget_EditItem(void* ptr, void* item, int column)
{
	static_cast<QTreeWidget*>(ptr)->editItem(static_cast<QTreeWidgetItem*>(item), column);
}

void QTreeWidget_ExpandItem(void* ptr, void* item)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "expandItem", Q_ARG(const QTreeWidgetItem*, static_cast<QTreeWidgetItem*>(item)));
}

void QTreeWidget_ExpandItemDefault(void* ptr, void* item)
{
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::expandItem(static_cast<QTreeWidgetItem*>(item));
}

struct QtWidgets_PackedList QTreeWidget_FindItems(void* ptr, struct QtWidgets_PackedString text, long long flags, int column)
{
	return ({ QList<QTreeWidgetItem *>* tmpValue92012a = new QList<QTreeWidgetItem *>(static_cast<QTreeWidget*>(ptr)->findItems(QString::fromUtf8(text.data, text.len), static_cast<Qt::MatchFlag>(flags), column)); QtWidgets_PackedList { tmpValue92012a, tmpValue92012a->size() }; });
}

void* QTreeWidget_HeaderItem(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->headerItem();
}

void* QTreeWidget_IndexFromItem(void* ptr, void* item, int column)
{
	return new QModelIndex(static_cast<QTreeWidget*>(ptr)->indexFromItem(static_cast<QTreeWidgetItem*>(item), column));
}

int QTreeWidget_IndexOfTopLevelItem(void* ptr, void* item)
{
	return static_cast<QTreeWidget*>(ptr)->indexOfTopLevelItem(static_cast<QTreeWidgetItem*>(item));
}

void QTreeWidget_InsertTopLevelItem(void* ptr, int index, void* item)
{
	static_cast<QTreeWidget*>(ptr)->insertTopLevelItem(index, static_cast<QTreeWidgetItem*>(item));
}

void QTreeWidget_InsertTopLevelItems(void* ptr, int index, void* items)
{
	static_cast<QTreeWidget*>(ptr)->insertTopLevelItems(index, *static_cast<QList<QTreeWidgetItem *>*>(items));
}

void* QTreeWidget_InvisibleRootItem(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->invisibleRootItem();
}

char QTreeWidget_IsPersistentEditorOpen(void* ptr, void* item, int column)
{
	return static_cast<QTreeWidget*>(ptr)->isPersistentEditorOpen(static_cast<QTreeWidgetItem*>(item), column);
}

void* QTreeWidget_ItemAbove(void* ptr, void* item)
{
	return static_cast<QTreeWidget*>(ptr)->itemAbove(static_cast<QTreeWidgetItem*>(item));
}

void QTreeWidget_ConnectItemActivated(void* ptr, long long t)
{
	QObject::connect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, int)>(&QTreeWidget::itemActivated), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, int)>(&MyQTreeWidget::Signal_ItemActivated), static_cast<Qt::ConnectionType>(t));
}

void QTreeWidget_DisconnectItemActivated(void* ptr)
{
	QObject::disconnect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, int)>(&QTreeWidget::itemActivated), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, int)>(&MyQTreeWidget::Signal_ItemActivated));
}

void QTreeWidget_ItemActivated(void* ptr, void* item, int column)
{
	static_cast<QTreeWidget*>(ptr)->itemActivated(static_cast<QTreeWidgetItem*>(item), column);
}

void* QTreeWidget_ItemAt(void* ptr, void* p)
{
	return static_cast<QTreeWidget*>(ptr)->itemAt(*static_cast<QPoint*>(p));
}

void* QTreeWidget_ItemAt2(void* ptr, int x, int y)
{
	return static_cast<QTreeWidget*>(ptr)->itemAt(x, y);
}

void* QTreeWidget_ItemBelow(void* ptr, void* item)
{
	return static_cast<QTreeWidget*>(ptr)->itemBelow(static_cast<QTreeWidgetItem*>(item));
}

void QTreeWidget_ConnectItemChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, int)>(&QTreeWidget::itemChanged), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, int)>(&MyQTreeWidget::Signal_ItemChanged), static_cast<Qt::ConnectionType>(t));
}

void QTreeWidget_DisconnectItemChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, int)>(&QTreeWidget::itemChanged), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, int)>(&MyQTreeWidget::Signal_ItemChanged));
}

void QTreeWidget_ItemChanged(void* ptr, void* item, int column)
{
	static_cast<QTreeWidget*>(ptr)->itemChanged(static_cast<QTreeWidgetItem*>(item), column);
}

void QTreeWidget_ConnectItemClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, int)>(&QTreeWidget::itemClicked), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, int)>(&MyQTreeWidget::Signal_ItemClicked), static_cast<Qt::ConnectionType>(t));
}

void QTreeWidget_DisconnectItemClicked(void* ptr)
{
	QObject::disconnect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, int)>(&QTreeWidget::itemClicked), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, int)>(&MyQTreeWidget::Signal_ItemClicked));
}

void QTreeWidget_ItemClicked(void* ptr, void* item, int column)
{
	static_cast<QTreeWidget*>(ptr)->itemClicked(static_cast<QTreeWidgetItem*>(item), column);
}

void QTreeWidget_ConnectItemCollapsed(void* ptr, long long t)
{
	QObject::connect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *)>(&QTreeWidget::itemCollapsed), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *)>(&MyQTreeWidget::Signal_ItemCollapsed), static_cast<Qt::ConnectionType>(t));
}

void QTreeWidget_DisconnectItemCollapsed(void* ptr)
{
	QObject::disconnect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *)>(&QTreeWidget::itemCollapsed), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *)>(&MyQTreeWidget::Signal_ItemCollapsed));
}

void QTreeWidget_ItemCollapsed(void* ptr, void* item)
{
	static_cast<QTreeWidget*>(ptr)->itemCollapsed(static_cast<QTreeWidgetItem*>(item));
}

void QTreeWidget_ConnectItemDoubleClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, int)>(&QTreeWidget::itemDoubleClicked), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, int)>(&MyQTreeWidget::Signal_ItemDoubleClicked), static_cast<Qt::ConnectionType>(t));
}

void QTreeWidget_DisconnectItemDoubleClicked(void* ptr)
{
	QObject::disconnect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, int)>(&QTreeWidget::itemDoubleClicked), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, int)>(&MyQTreeWidget::Signal_ItemDoubleClicked));
}

void QTreeWidget_ItemDoubleClicked(void* ptr, void* item, int column)
{
	static_cast<QTreeWidget*>(ptr)->itemDoubleClicked(static_cast<QTreeWidgetItem*>(item), column);
}

void QTreeWidget_ConnectItemEntered(void* ptr, long long t)
{
	QObject::connect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, int)>(&QTreeWidget::itemEntered), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, int)>(&MyQTreeWidget::Signal_ItemEntered), static_cast<Qt::ConnectionType>(t));
}

void QTreeWidget_DisconnectItemEntered(void* ptr)
{
	QObject::disconnect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, int)>(&QTreeWidget::itemEntered), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, int)>(&MyQTreeWidget::Signal_ItemEntered));
}

void QTreeWidget_ItemEntered(void* ptr, void* item, int column)
{
	static_cast<QTreeWidget*>(ptr)->itemEntered(static_cast<QTreeWidgetItem*>(item), column);
}

void QTreeWidget_ConnectItemExpanded(void* ptr, long long t)
{
	QObject::connect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *)>(&QTreeWidget::itemExpanded), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *)>(&MyQTreeWidget::Signal_ItemExpanded), static_cast<Qt::ConnectionType>(t));
}

void QTreeWidget_DisconnectItemExpanded(void* ptr)
{
	QObject::disconnect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *)>(&QTreeWidget::itemExpanded), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *)>(&MyQTreeWidget::Signal_ItemExpanded));
}

void QTreeWidget_ItemExpanded(void* ptr, void* item)
{
	static_cast<QTreeWidget*>(ptr)->itemExpanded(static_cast<QTreeWidgetItem*>(item));
}

void* QTreeWidget_ItemFromIndex(void* ptr, void* index)
{
	return static_cast<QTreeWidget*>(ptr)->itemFromIndex(*static_cast<QModelIndex*>(index));
}

void QTreeWidget_ConnectItemPressed(void* ptr, long long t)
{
	QObject::connect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, int)>(&QTreeWidget::itemPressed), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, int)>(&MyQTreeWidget::Signal_ItemPressed), static_cast<Qt::ConnectionType>(t));
}

void QTreeWidget_DisconnectItemPressed(void* ptr)
{
	QObject::disconnect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)(QTreeWidgetItem *, int)>(&QTreeWidget::itemPressed), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)(QTreeWidgetItem *, int)>(&MyQTreeWidget::Signal_ItemPressed));
}

void QTreeWidget_ItemPressed(void* ptr, void* item, int column)
{
	static_cast<QTreeWidget*>(ptr)->itemPressed(static_cast<QTreeWidgetItem*>(item), column);
}

void QTreeWidget_ConnectItemSelectionChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)()>(&QTreeWidget::itemSelectionChanged), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)()>(&MyQTreeWidget::Signal_ItemSelectionChanged), static_cast<Qt::ConnectionType>(t));
}

void QTreeWidget_DisconnectItemSelectionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)()>(&QTreeWidget::itemSelectionChanged), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)()>(&MyQTreeWidget::Signal_ItemSelectionChanged));
}

void QTreeWidget_ItemSelectionChanged(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->itemSelectionChanged();
}

void* QTreeWidget_ItemWidget(void* ptr, void* item, int column)
{
	return static_cast<QTreeWidget*>(ptr)->itemWidget(static_cast<QTreeWidgetItem*>(item), column);
}

void* QTreeWidget_MimeData(void* ptr, void* items)
{
	return static_cast<QTreeWidget*>(ptr)->mimeData(*static_cast<QList<QTreeWidgetItem *>*>(items));
}

void* QTreeWidget_MimeDataDefault(void* ptr, void* items)
{
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::mimeData(*static_cast<QList<QTreeWidgetItem *>*>(items));
}

struct QtWidgets_PackedString QTreeWidget_MimeTypes(void* ptr)
{
	return ({ QByteArray* t212f68 = new QByteArray(static_cast<QTreeWidget*>(ptr)->mimeTypes().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(t212f68->prepend("WHITESPACE").constData()+10), t212f68->size()-10, t212f68 }; });
}

struct QtWidgets_PackedString QTreeWidget_MimeTypesDefault(void* ptr)
{
		return ({ QByteArray* te2438e = new QByteArray(static_cast<QTreeWidget*>(ptr)->QTreeWidget::mimeTypes().join("¡¦!").toUtf8()); QtWidgets_PackedString { const_cast<char*>(te2438e->prepend("WHITESPACE").constData()+10), te2438e->size()-10, te2438e }; });
}

void QTreeWidget_OpenPersistentEditor(void* ptr, void* item, int column)
{
	static_cast<QTreeWidget*>(ptr)->openPersistentEditor(static_cast<QTreeWidgetItem*>(item), column);
}

void QTreeWidget_RemoveItemWidget(void* ptr, void* item, int column)
{
	static_cast<QTreeWidget*>(ptr)->removeItemWidget(static_cast<QTreeWidgetItem*>(item), column);
}

void QTreeWidget_ScrollToItem(void* ptr, void* item, long long hint)
{
	qRegisterMetaType<QAbstractItemView::ScrollHint>();
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "scrollToItem", Q_ARG(const QTreeWidgetItem*, static_cast<QTreeWidgetItem*>(item)), Q_ARG(QAbstractItemView::ScrollHint, static_cast<QAbstractItemView::ScrollHint>(hint)));
}

void QTreeWidget_ScrollToItemDefault(void* ptr, void* item, long long hint)
{
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::scrollToItem(static_cast<QTreeWidgetItem*>(item), static_cast<QAbstractItemView::ScrollHint>(hint));
}

struct QtWidgets_PackedList QTreeWidget_SelectedItems(void* ptr)
{
	return ({ QList<QTreeWidgetItem *>* tmpValueb64487 = new QList<QTreeWidgetItem *>(static_cast<QTreeWidget*>(ptr)->selectedItems()); QtWidgets_PackedList { tmpValueb64487, tmpValueb64487->size() }; });
}

void QTreeWidget_SetColumnCount(void* ptr, int columns)
{
	static_cast<QTreeWidget*>(ptr)->setColumnCount(columns);
}

void QTreeWidget_SetCurrentItem(void* ptr, void* item)
{
	static_cast<QTreeWidget*>(ptr)->setCurrentItem(static_cast<QTreeWidgetItem*>(item));
}

void QTreeWidget_SetCurrentItem2(void* ptr, void* item, int column)
{
	static_cast<QTreeWidget*>(ptr)->setCurrentItem(static_cast<QTreeWidgetItem*>(item), column);
}

void QTreeWidget_SetCurrentItem3(void* ptr, void* item, int column, long long command)
{
	static_cast<QTreeWidget*>(ptr)->setCurrentItem(static_cast<QTreeWidgetItem*>(item), column, static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QTreeWidget_SetHeaderItem(void* ptr, void* item)
{
	static_cast<QTreeWidget*>(ptr)->setHeaderItem(static_cast<QTreeWidgetItem*>(item));
}

void QTreeWidget_SetHeaderLabel(void* ptr, struct QtWidgets_PackedString label)
{
	static_cast<QTreeWidget*>(ptr)->setHeaderLabel(QString::fromUtf8(label.data, label.len));
}

void QTreeWidget_SetHeaderLabels(void* ptr, struct QtWidgets_PackedString labels)
{
	static_cast<QTreeWidget*>(ptr)->setHeaderLabels(QString::fromUtf8(labels.data, labels.len).split("¡¦!", QString::SkipEmptyParts));
}

void QTreeWidget_SetItemWidget(void* ptr, void* item, int column, void* widget)
{
		static_cast<QTreeWidget*>(ptr)->setItemWidget(static_cast<QTreeWidgetItem*>(item), column, static_cast<QWidget*>(widget));
}

int QTreeWidget_SortColumn(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->sortColumn();
}

void QTreeWidget_SortItems(void* ptr, int column, long long order)
{
	static_cast<QTreeWidget*>(ptr)->sortItems(column, static_cast<Qt::SortOrder>(order));
}

long long QTreeWidget_SupportedDropActions(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->supportedDropActions();
}

long long QTreeWidget_SupportedDropActionsDefault(void* ptr)
{
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::supportedDropActions();
}

void* QTreeWidget_TakeTopLevelItem(void* ptr, int index)
{
	return static_cast<QTreeWidget*>(ptr)->takeTopLevelItem(index);
}

void* QTreeWidget_TopLevelItem(void* ptr, int index)
{
	return static_cast<QTreeWidget*>(ptr)->topLevelItem(index);
}

int QTreeWidget_TopLevelItemCount(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->topLevelItemCount();
}

void* QTreeWidget_VisualItemRect(void* ptr, void* item)
{
	return ({ QRect tmpValue = static_cast<QTreeWidget*>(ptr)->visualItemRect(static_cast<QTreeWidgetItem*>(item)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QTreeWidget_DestroyQTreeWidget(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->~QTreeWidget();
}

void QTreeWidget_DestroyQTreeWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QTreeWidget___addTopLevelItems_items_atList(void* ptr, int i)
{
	return ({QTreeWidgetItem * tmp = static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTreeWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTreeWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTreeWidget___addTopLevelItems_items_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTreeWidgetItem *>();
}

void* QTreeWidget___findItems_atList(void* ptr, int i)
{
	return ({QTreeWidgetItem * tmp = static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTreeWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTreeWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTreeWidget___findItems_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTreeWidgetItem *>();
}

void* QTreeWidget___insertTopLevelItems_items_atList(void* ptr, int i)
{
	return ({QTreeWidgetItem * tmp = static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTreeWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTreeWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTreeWidget___insertTopLevelItems_items_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTreeWidgetItem *>();
}

void* QTreeWidget___items_atList(void* ptr, int i)
{
	return ({QTreeWidgetItem * tmp = static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTreeWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTreeWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTreeWidget___items_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTreeWidgetItem *>();
}

void* QTreeWidget___mimeData_items_atList(void* ptr, int i)
{
	return ({QTreeWidgetItem * tmp = static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTreeWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTreeWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTreeWidget___mimeData_items_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTreeWidgetItem *>();
}

void* QTreeWidget___selectedItems_atList(void* ptr, int i)
{
	return ({QTreeWidgetItem * tmp = static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTreeWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTreeWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTreeWidget___selectedItems_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTreeWidgetItem *>();
}

class MyQTreeWidgetItem: public QTreeWidgetItem
{
public:
	MyQTreeWidgetItem(int ty = Type) : QTreeWidgetItem(ty) {QTreeWidgetItem_QTreeWidgetItem_QRegisterMetaType();};
	MyQTreeWidgetItem(const QStringList &strin, int ty = Type) : QTreeWidgetItem(strin, ty) {QTreeWidgetItem_QTreeWidgetItem_QRegisterMetaType();};
	MyQTreeWidgetItem(QTreeWidget *parent, int ty = Type) : QTreeWidgetItem(parent, ty) {QTreeWidgetItem_QTreeWidgetItem_QRegisterMetaType();};
	MyQTreeWidgetItem(QTreeWidget *parent, const QStringList &strin, int ty = Type) : QTreeWidgetItem(parent, strin, ty) {QTreeWidgetItem_QTreeWidgetItem_QRegisterMetaType();};
	MyQTreeWidgetItem(QTreeWidget *parent, QTreeWidgetItem *preceding, int ty = Type) : QTreeWidgetItem(parent, preceding, ty) {QTreeWidgetItem_QTreeWidgetItem_QRegisterMetaType();};
	MyQTreeWidgetItem(QTreeWidgetItem *parent, int ty = Type) : QTreeWidgetItem(parent, ty) {QTreeWidgetItem_QTreeWidgetItem_QRegisterMetaType();};
	MyQTreeWidgetItem(QTreeWidgetItem *parent, const QStringList &strin, int ty = Type) : QTreeWidgetItem(parent, strin, ty) {QTreeWidgetItem_QTreeWidgetItem_QRegisterMetaType();};
	MyQTreeWidgetItem(QTreeWidgetItem *parent, QTreeWidgetItem *preceding, int ty = Type) : QTreeWidgetItem(parent, preceding, ty) {QTreeWidgetItem_QTreeWidgetItem_QRegisterMetaType();};
	MyQTreeWidgetItem(const QTreeWidgetItem &other) : QTreeWidgetItem(other) {QTreeWidgetItem_QTreeWidgetItem_QRegisterMetaType();};
	QTreeWidgetItem * clone() const { return static_cast<QTreeWidgetItem*>(callbackQTreeWidgetItem_Clone(const_cast<void*>(static_cast<const void*>(this)))); };
	QVariant data(int column, int role) const { return *static_cast<QVariant*>(callbackQTreeWidgetItem_Data(const_cast<void*>(static_cast<const void*>(this)), column, role)); };
	void read(QDataStream & in) { callbackQTreeWidgetItem_Read(this, static_cast<QDataStream*>(&in)); };
	void setData(int column, int role, const QVariant & value) { callbackQTreeWidgetItem_SetData(this, column, role, const_cast<QVariant*>(&value)); };
	void write(QDataStream & out) const { callbackQTreeWidgetItem_Write(const_cast<void*>(static_cast<const void*>(this)), static_cast<QDataStream*>(&out)); };
	 ~MyQTreeWidgetItem() { callbackQTreeWidgetItem_DestroyQTreeWidgetItem(this); };
};

Q_DECLARE_METATYPE(QTreeWidgetItem*)
Q_DECLARE_METATYPE(MyQTreeWidgetItem*)

int QTreeWidgetItem_QTreeWidgetItem_QRegisterMetaType(){qRegisterMetaType<QTreeWidgetItem*>(); return qRegisterMetaType<MyQTreeWidgetItem*>();}

void* QTreeWidgetItem_NewQTreeWidgetItem(int ty)
{
	return new MyQTreeWidgetItem(ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem2(struct QtWidgets_PackedString strin, int ty)
{
	return new MyQTreeWidgetItem(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem3(void* parent, int ty)
{
	return new MyQTreeWidgetItem(static_cast<QTreeWidget*>(parent), ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem4(void* parent, struct QtWidgets_PackedString strin, int ty)
{
	return new MyQTreeWidgetItem(static_cast<QTreeWidget*>(parent), QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem5(void* parent, void* preceding, int ty)
{
	return new MyQTreeWidgetItem(static_cast<QTreeWidget*>(parent), static_cast<QTreeWidgetItem*>(preceding), ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem6(void* parent, int ty)
{
	return new MyQTreeWidgetItem(static_cast<QTreeWidgetItem*>(parent), ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem7(void* parent, struct QtWidgets_PackedString strin, int ty)
{
	return new MyQTreeWidgetItem(static_cast<QTreeWidgetItem*>(parent), QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem8(void* parent, void* preceding, int ty)
{
	return new MyQTreeWidgetItem(static_cast<QTreeWidgetItem*>(parent), static_cast<QTreeWidgetItem*>(preceding), ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem9(void* other)
{
	return new MyQTreeWidgetItem(*static_cast<QTreeWidgetItem*>(other));
}

void QTreeWidgetItem_AddChild(void* ptr, void* child)
{
	static_cast<QTreeWidgetItem*>(ptr)->addChild(static_cast<QTreeWidgetItem*>(child));
}

void QTreeWidgetItem_AddChildren(void* ptr, void* children)
{
	static_cast<QTreeWidgetItem*>(ptr)->addChildren(*static_cast<QList<QTreeWidgetItem *>*>(children));
}

void* QTreeWidgetItem_Background(void* ptr, int column)
{
	return new QBrush(static_cast<QTreeWidgetItem*>(ptr)->background(column));
}

long long QTreeWidgetItem_CheckState(void* ptr, int column)
{
	return static_cast<QTreeWidgetItem*>(ptr)->checkState(column);
}

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

int QTreeWidgetItem_ChildCount(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->childCount();
}

long long QTreeWidgetItem_ChildIndicatorPolicy(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->childIndicatorPolicy();
}

void* QTreeWidgetItem_Clone(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->clone();
}

void* QTreeWidgetItem_CloneDefault(void* ptr)
{
		return static_cast<QTreeWidgetItem*>(ptr)->QTreeWidgetItem::clone();
}

int QTreeWidgetItem_ColumnCount(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->columnCount();
}

void* QTreeWidgetItem_Data(void* ptr, int column, int role)
{
	return new QVariant(static_cast<QTreeWidgetItem*>(ptr)->data(column, role));
}

void* QTreeWidgetItem_DataDefault(void* ptr, int column, int role)
{
		return new QVariant(static_cast<QTreeWidgetItem*>(ptr)->QTreeWidgetItem::data(column, role));
}

void QTreeWidgetItem_EmitDataChanged(void* ptr)
{
	static_cast<QTreeWidgetItem*>(ptr)->emitDataChanged();
}

long long QTreeWidgetItem_Flags(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->flags();
}

void* QTreeWidgetItem_Font(void* ptr, int column)
{
	return new QFont(static_cast<QTreeWidgetItem*>(ptr)->font(column));
}

void* QTreeWidgetItem_Foreground(void* ptr, int column)
{
	return new QBrush(static_cast<QTreeWidgetItem*>(ptr)->foreground(column));
}

void* QTreeWidgetItem_Icon(void* ptr, int column)
{
	return new QIcon(static_cast<QTreeWidgetItem*>(ptr)->icon(column));
}

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

void QTreeWidgetItem_InsertChild(void* ptr, int index, void* child)
{
	static_cast<QTreeWidgetItem*>(ptr)->insertChild(index, static_cast<QTreeWidgetItem*>(child));
}

void QTreeWidgetItem_InsertChildren(void* ptr, int index, void* children)
{
	static_cast<QTreeWidgetItem*>(ptr)->insertChildren(index, *static_cast<QList<QTreeWidgetItem *>*>(children));
}

char QTreeWidgetItem_IsDisabled(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->isDisabled();
}

char QTreeWidgetItem_IsExpanded(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->isExpanded();
}

char QTreeWidgetItem_IsFirstColumnSpanned(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->isFirstColumnSpanned();
}

char QTreeWidgetItem_IsHidden(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->isHidden();
}

char QTreeWidgetItem_IsSelected(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->isSelected();
}

void* QTreeWidgetItem_Parent(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->parent();
}

void QTreeWidgetItem_Read(void* ptr, void* in)
{
	static_cast<QTreeWidgetItem*>(ptr)->read(*static_cast<QDataStream*>(in));
}

void QTreeWidgetItem_ReadDefault(void* ptr, void* in)
{
		static_cast<QTreeWidgetItem*>(ptr)->QTreeWidgetItem::read(*static_cast<QDataStream*>(in));
}

void QTreeWidgetItem_RemoveChild(void* ptr, void* child)
{
	static_cast<QTreeWidgetItem*>(ptr)->removeChild(static_cast<QTreeWidgetItem*>(child));
}

void QTreeWidgetItem_SetBackground(void* ptr, int column, void* brush)
{
	static_cast<QTreeWidgetItem*>(ptr)->setBackground(column, *static_cast<QBrush*>(brush));
}

void QTreeWidgetItem_SetCheckState(void* ptr, int column, long long state)
{
	static_cast<QTreeWidgetItem*>(ptr)->setCheckState(column, static_cast<Qt::CheckState>(state));
}

void QTreeWidgetItem_SetChildIndicatorPolicy(void* ptr, long long policy)
{
	static_cast<QTreeWidgetItem*>(ptr)->setChildIndicatorPolicy(static_cast<QTreeWidgetItem::ChildIndicatorPolicy>(policy));
}

void QTreeWidgetItem_SetData(void* ptr, int column, int role, void* value)
{
	static_cast<QTreeWidgetItem*>(ptr)->setData(column, role, *static_cast<QVariant*>(value));
}

void QTreeWidgetItem_SetDataDefault(void* ptr, int column, int role, void* value)
{
		static_cast<QTreeWidgetItem*>(ptr)->QTreeWidgetItem::setData(column, role, *static_cast<QVariant*>(value));
}

void QTreeWidgetItem_SetDisabled(void* ptr, char disabled)
{
	static_cast<QTreeWidgetItem*>(ptr)->setDisabled(disabled != 0);
}

void QTreeWidgetItem_SetExpanded(void* ptr, char expand)
{
	static_cast<QTreeWidgetItem*>(ptr)->setExpanded(expand != 0);
}

void QTreeWidgetItem_SetFirstColumnSpanned(void* ptr, char span)
{
	static_cast<QTreeWidgetItem*>(ptr)->setFirstColumnSpanned(span != 0);
}

void QTreeWidgetItem_SetFlags(void* ptr, long long flags)
{
	static_cast<QTreeWidgetItem*>(ptr)->setFlags(static_cast<Qt::ItemFlag>(flags));
}

void QTreeWidgetItem_SetFont(void* ptr, int column, void* font)
{
	static_cast<QTreeWidgetItem*>(ptr)->setFont(column, *static_cast<QFont*>(font));
}

void QTreeWidgetItem_SetForeground(void* ptr, int column, void* brush)
{
	static_cast<QTreeWidgetItem*>(ptr)->setForeground(column, *static_cast<QBrush*>(brush));
}

void QTreeWidgetItem_SetHidden(void* ptr, char hide)
{
	static_cast<QTreeWidgetItem*>(ptr)->setHidden(hide != 0);
}

void QTreeWidgetItem_SetIcon(void* ptr, int column, void* icon)
{
	static_cast<QTreeWidgetItem*>(ptr)->setIcon(column, *static_cast<QIcon*>(icon));
}

void QTreeWidgetItem_SetSelected(void* ptr, char sele)
{
	static_cast<QTreeWidgetItem*>(ptr)->setSelected(sele != 0);
}

void QTreeWidgetItem_SetSizeHint(void* ptr, int column, void* size)
{
	static_cast<QTreeWidgetItem*>(ptr)->setSizeHint(column, *static_cast<QSize*>(size));
}

void QTreeWidgetItem_SetStatusTip(void* ptr, int column, struct QtWidgets_PackedString statusTip)
{
	static_cast<QTreeWidgetItem*>(ptr)->setStatusTip(column, QString::fromUtf8(statusTip.data, statusTip.len));
}

void QTreeWidgetItem_SetText(void* ptr, int column, struct QtWidgets_PackedString text)
{
	static_cast<QTreeWidgetItem*>(ptr)->setText(column, QString::fromUtf8(text.data, text.len));
}

void QTreeWidgetItem_SetTextAlignment(void* ptr, int column, int alignment)
{
	static_cast<QTreeWidgetItem*>(ptr)->setTextAlignment(column, alignment);
}

void QTreeWidgetItem_SetToolTip(void* ptr, int column, struct QtWidgets_PackedString toolTip)
{
	static_cast<QTreeWidgetItem*>(ptr)->setToolTip(column, QString::fromUtf8(toolTip.data, toolTip.len));
}

void QTreeWidgetItem_SetWhatsThis(void* ptr, int column, struct QtWidgets_PackedString whatsThis)
{
	static_cast<QTreeWidgetItem*>(ptr)->setWhatsThis(column, QString::fromUtf8(whatsThis.data, whatsThis.len));
}

void* QTreeWidgetItem_SizeHint(void* ptr, int column)
{
	return ({ QSize tmpValue = static_cast<QTreeWidgetItem*>(ptr)->sizeHint(column); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTreeWidgetItem_SortChildren(void* ptr, int column, long long order)
{
	static_cast<QTreeWidgetItem*>(ptr)->sortChildren(column, static_cast<Qt::SortOrder>(order));
}

struct QtWidgets_PackedString QTreeWidgetItem_StatusTip(void* ptr, int column)
{
	return ({ QByteArray* t848a1d = new QByteArray(static_cast<QTreeWidgetItem*>(ptr)->statusTip(column).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t848a1d->prepend("WHITESPACE").constData()+10), t848a1d->size()-10, t848a1d }; });
}

void* QTreeWidgetItem_TakeChild(void* ptr, int index)
{
	return static_cast<QTreeWidgetItem*>(ptr)->takeChild(index);
}

struct QtWidgets_PackedList QTreeWidgetItem_TakeChildren(void* ptr)
{
	return ({ QList<QTreeWidgetItem *>* tmpValue517109 = new QList<QTreeWidgetItem *>(static_cast<QTreeWidgetItem*>(ptr)->takeChildren()); QtWidgets_PackedList { tmpValue517109, tmpValue517109->size() }; });
}

struct QtWidgets_PackedString QTreeWidgetItem_Text(void* ptr, int column)
{
	return ({ QByteArray* t0b76f8 = new QByteArray(static_cast<QTreeWidgetItem*>(ptr)->text(column).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t0b76f8->prepend("WHITESPACE").constData()+10), t0b76f8->size()-10, t0b76f8 }; });
}

int QTreeWidgetItem_TextAlignment(void* ptr, int column)
{
	return static_cast<QTreeWidgetItem*>(ptr)->textAlignment(column);
}

struct QtWidgets_PackedString QTreeWidgetItem_ToolTip(void* ptr, int column)
{
	return ({ QByteArray* tdec4c7 = new QByteArray(static_cast<QTreeWidgetItem*>(ptr)->toolTip(column).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tdec4c7->prepend("WHITESPACE").constData()+10), tdec4c7->size()-10, tdec4c7 }; });
}

void* QTreeWidgetItem_TreeWidget(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->treeWidget();
}

int QTreeWidgetItem_Type(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->type();
}

struct QtWidgets_PackedString QTreeWidgetItem_WhatsThis(void* ptr, int column)
{
	return ({ QByteArray* te93ad0 = new QByteArray(static_cast<QTreeWidgetItem*>(ptr)->whatsThis(column).toUtf8()); QtWidgets_PackedString { const_cast<char*>(te93ad0->prepend("WHITESPACE").constData()+10), te93ad0->size()-10, te93ad0 }; });
}

void QTreeWidgetItem_Write(void* ptr, void* out)
{
	static_cast<QTreeWidgetItem*>(ptr)->write(*static_cast<QDataStream*>(out));
}

void QTreeWidgetItem_WriteDefault(void* ptr, void* out)
{
		static_cast<QTreeWidgetItem*>(ptr)->QTreeWidgetItem::write(*static_cast<QDataStream*>(out));
}

void QTreeWidgetItem_DestroyQTreeWidgetItem(void* ptr)
{
	static_cast<QTreeWidgetItem*>(ptr)->~QTreeWidgetItem();
}

void QTreeWidgetItem_DestroyQTreeWidgetItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QTreeWidgetItem___addChildren_children_atList(void* ptr, int i)
{
	return ({QTreeWidgetItem * tmp = static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTreeWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTreeWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTreeWidgetItem___addChildren_children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTreeWidgetItem *>();
}

void* QTreeWidgetItem___insertChildren_children_atList(void* ptr, int i)
{
	return ({QTreeWidgetItem * tmp = static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTreeWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTreeWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTreeWidgetItem___insertChildren_children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTreeWidgetItem *>();
}

void* QTreeWidgetItem___takeChildren_atList(void* ptr, int i)
{
	return ({QTreeWidgetItem * tmp = static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTreeWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTreeWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTreeWidgetItem___takeChildren_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTreeWidgetItem *>();
}

void* QTreeWidgetItem___children_atList(void* ptr, int i)
{
	return ({QTreeWidgetItem * tmp = static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTreeWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTreeWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTreeWidgetItem___children_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTreeWidgetItem *>();
}

void* QTreeWidgetItem___setChildren__atList(void* ptr, int i)
{
	return ({QTreeWidgetItem * tmp = static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i); if (i == static_cast<QList<QTreeWidgetItem *>*>(ptr)->size()-1) { static_cast<QList<QTreeWidgetItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QTreeWidgetItem___setChildren__newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QTreeWidgetItem *>();
}

class MyQUndoCommand: public QUndoCommand
{
public:
	MyQUndoCommand(QUndoCommand *parent = Q_NULLPTR) : QUndoCommand(parent) {QUndoCommand_QUndoCommand_QRegisterMetaType();};
	MyQUndoCommand(const QString &text, QUndoCommand *parent = Q_NULLPTR) : QUndoCommand(text, parent) {QUndoCommand_QUndoCommand_QRegisterMetaType();};
	int id() const { return callbackQUndoCommand_Id(const_cast<void*>(static_cast<const void*>(this))); };
	bool mergeWith(const QUndoCommand * command) { return callbackQUndoCommand_MergeWith(this, const_cast<QUndoCommand*>(command)) != 0; };
	void redo() { callbackQUndoCommand_Redo(this); };
	void undo() { callbackQUndoCommand_Undo(this); };
	 ~MyQUndoCommand() { callbackQUndoCommand_DestroyQUndoCommand(this); };
};

Q_DECLARE_METATYPE(QUndoCommand*)
Q_DECLARE_METATYPE(MyQUndoCommand*)

int QUndoCommand_QUndoCommand_QRegisterMetaType(){qRegisterMetaType<QUndoCommand*>(); return qRegisterMetaType<MyQUndoCommand*>();}

void* QUndoCommand_NewQUndoCommand(void* parent)
{
	return new MyQUndoCommand(static_cast<QUndoCommand*>(parent));
}

void* QUndoCommand_NewQUndoCommand2(struct QtWidgets_PackedString text, void* parent)
{
	return new MyQUndoCommand(QString::fromUtf8(text.data, text.len), static_cast<QUndoCommand*>(parent));
}

struct QtWidgets_PackedString QUndoCommand_ActionText(void* ptr)
{
	return ({ QByteArray* t4cb828 = new QByteArray(static_cast<QUndoCommand*>(ptr)->actionText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t4cb828->prepend("WHITESPACE").constData()+10), t4cb828->size()-10, t4cb828 }; });
}

void* QUndoCommand_Child(void* ptr, int index)
{
	return const_cast<QUndoCommand*>(static_cast<QUndoCommand*>(ptr)->child(index));
}

int QUndoCommand_ChildCount(void* ptr)
{
	return static_cast<QUndoCommand*>(ptr)->childCount();
}

int QUndoCommand_Id(void* ptr)
{
	return static_cast<QUndoCommand*>(ptr)->id();
}

int QUndoCommand_IdDefault(void* ptr)
{
		return static_cast<QUndoCommand*>(ptr)->QUndoCommand::id();
}

char QUndoCommand_IsObsolete(void* ptr)
{
	return static_cast<QUndoCommand*>(ptr)->isObsolete();
}

char QUndoCommand_MergeWith(void* ptr, void* command)
{
	return static_cast<QUndoCommand*>(ptr)->mergeWith(static_cast<QUndoCommand*>(command));
}

char QUndoCommand_MergeWithDefault(void* ptr, void* command)
{
		return static_cast<QUndoCommand*>(ptr)->QUndoCommand::mergeWith(static_cast<QUndoCommand*>(command));
}

void QUndoCommand_Redo(void* ptr)
{
	static_cast<QUndoCommand*>(ptr)->redo();
}

void QUndoCommand_RedoDefault(void* ptr)
{
		static_cast<QUndoCommand*>(ptr)->QUndoCommand::redo();
}

void QUndoCommand_SetObsolete(void* ptr, char obsolete)
{
	static_cast<QUndoCommand*>(ptr)->setObsolete(obsolete != 0);
}

void QUndoCommand_SetText(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QUndoCommand*>(ptr)->setText(QString::fromUtf8(text.data, text.len));
}

struct QtWidgets_PackedString QUndoCommand_Text(void* ptr)
{
	return ({ QByteArray* t68d93e = new QByteArray(static_cast<QUndoCommand*>(ptr)->text().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t68d93e->prepend("WHITESPACE").constData()+10), t68d93e->size()-10, t68d93e }; });
}

void QUndoCommand_Undo(void* ptr)
{
	static_cast<QUndoCommand*>(ptr)->undo();
}

void QUndoCommand_UndoDefault(void* ptr)
{
		static_cast<QUndoCommand*>(ptr)->QUndoCommand::undo();
}

void QUndoCommand_DestroyQUndoCommand(void* ptr)
{
	static_cast<QUndoCommand*>(ptr)->~QUndoCommand();
}

void QUndoCommand_DestroyQUndoCommandDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQUndoGroup: public QUndoGroup
{
public:
	MyQUndoGroup(QObject *parent = Q_NULLPTR) : QUndoGroup(parent) {QUndoGroup_QUndoGroup_QRegisterMetaType();};
	void Signal_ActiveStackChanged(QUndoStack * stack) { callbackQUndoGroup_ActiveStackChanged(this, stack); };
	void Signal_CanRedoChanged(bool canRedo) { callbackQUndoGroup_CanRedoChanged(this, canRedo); };
	void Signal_CanUndoChanged(bool canUndo) { callbackQUndoGroup_CanUndoChanged(this, canUndo); };
	void Signal_CleanChanged(bool clean) { callbackQUndoGroup_CleanChanged(this, clean); };
	void Signal_IndexChanged(int idx) { callbackQUndoGroup_IndexChanged(this, idx); };
	void redo() { callbackQUndoGroup_Redo(this); };
	void Signal_RedoTextChanged(const QString & redoText) { QByteArray* te82275 = new QByteArray(redoText.toUtf8()); QtWidgets_PackedString redoTextPacked = { const_cast<char*>(te82275->prepend("WHITESPACE").constData()+10), te82275->size()-10, te82275 };callbackQUndoGroup_RedoTextChanged(this, redoTextPacked); };
	void setActiveStack(QUndoStack * stack) { callbackQUndoGroup_SetActiveStack(this, stack); };
	void undo() { callbackQUndoGroup_Undo(this); };
	void Signal_UndoTextChanged(const QString & undoText) { QByteArray* t66d0aa = new QByteArray(undoText.toUtf8()); QtWidgets_PackedString undoTextPacked = { const_cast<char*>(t66d0aa->prepend("WHITESPACE").constData()+10), t66d0aa->size()-10, t66d0aa };callbackQUndoGroup_UndoTextChanged(this, undoTextPacked); };
	 ~MyQUndoGroup() { callbackQUndoGroup_DestroyQUndoGroup(this); };
	void childEvent(QChildEvent * event) { callbackQUndoGroup_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQUndoGroup_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQUndoGroup_CustomEvent(this, event); };
	void deleteLater() { callbackQUndoGroup_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQUndoGroup_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQUndoGroup_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQUndoGroup_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQUndoGroup_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQUndoGroup_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQUndoGroup_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQUndoGroup_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QUndoGroup*)
Q_DECLARE_METATYPE(MyQUndoGroup*)

int QUndoGroup_QUndoGroup_QRegisterMetaType(){qRegisterMetaType<QUndoGroup*>(); return qRegisterMetaType<MyQUndoGroup*>();}

void* QUndoGroup_NewQUndoGroup(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQUndoGroup(static_cast<QWindow*>(parent));
	} else {
		return new MyQUndoGroup(static_cast<QObject*>(parent));
	}
}

void* QUndoGroup_ActiveStack(void* ptr)
{
	return static_cast<QUndoGroup*>(ptr)->activeStack();
}

void QUndoGroup_ConnectActiveStackChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(QUndoStack *)>(&QUndoGroup::activeStackChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(QUndoStack *)>(&MyQUndoGroup::Signal_ActiveStackChanged), static_cast<Qt::ConnectionType>(t));
}

void QUndoGroup_DisconnectActiveStackChanged(void* ptr)
{
	QObject::disconnect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(QUndoStack *)>(&QUndoGroup::activeStackChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(QUndoStack *)>(&MyQUndoGroup::Signal_ActiveStackChanged));
}

void QUndoGroup_ActiveStackChanged(void* ptr, void* stack)
{
	static_cast<QUndoGroup*>(ptr)->activeStackChanged(static_cast<QUndoStack*>(stack));
}

void QUndoGroup_AddStack(void* ptr, void* stack)
{
	static_cast<QUndoGroup*>(ptr)->addStack(static_cast<QUndoStack*>(stack));
}

char QUndoGroup_CanRedo(void* ptr)
{
	return static_cast<QUndoGroup*>(ptr)->canRedo();
}

void QUndoGroup_ConnectCanRedoChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(bool)>(&QUndoGroup::canRedoChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(bool)>(&MyQUndoGroup::Signal_CanRedoChanged), static_cast<Qt::ConnectionType>(t));
}

void QUndoGroup_DisconnectCanRedoChanged(void* ptr)
{
	QObject::disconnect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(bool)>(&QUndoGroup::canRedoChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(bool)>(&MyQUndoGroup::Signal_CanRedoChanged));
}

void QUndoGroup_CanRedoChanged(void* ptr, char canRedo)
{
	static_cast<QUndoGroup*>(ptr)->canRedoChanged(canRedo != 0);
}

char QUndoGroup_CanUndo(void* ptr)
{
	return static_cast<QUndoGroup*>(ptr)->canUndo();
}

void QUndoGroup_ConnectCanUndoChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(bool)>(&QUndoGroup::canUndoChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(bool)>(&MyQUndoGroup::Signal_CanUndoChanged), static_cast<Qt::ConnectionType>(t));
}

void QUndoGroup_DisconnectCanUndoChanged(void* ptr)
{
	QObject::disconnect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(bool)>(&QUndoGroup::canUndoChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(bool)>(&MyQUndoGroup::Signal_CanUndoChanged));
}

void QUndoGroup_CanUndoChanged(void* ptr, char canUndo)
{
	static_cast<QUndoGroup*>(ptr)->canUndoChanged(canUndo != 0);
}

void QUndoGroup_ConnectCleanChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(bool)>(&QUndoGroup::cleanChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(bool)>(&MyQUndoGroup::Signal_CleanChanged), static_cast<Qt::ConnectionType>(t));
}

void QUndoGroup_DisconnectCleanChanged(void* ptr)
{
	QObject::disconnect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(bool)>(&QUndoGroup::cleanChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(bool)>(&MyQUndoGroup::Signal_CleanChanged));
}

void QUndoGroup_CleanChanged(void* ptr, char clean)
{
	static_cast<QUndoGroup*>(ptr)->cleanChanged(clean != 0);
}

void* QUndoGroup_CreateRedoAction(void* ptr, void* parent, struct QtWidgets_PackedString prefix)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoGroup*>(ptr)->createRedoAction(static_cast<QGraphicsObject*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoGroup*>(ptr)->createRedoAction(static_cast<QGraphicsWidget*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoGroup*>(ptr)->createRedoAction(static_cast<QLayout*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoGroup*>(ptr)->createRedoAction(static_cast<QWidget*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else {
		return static_cast<QUndoGroup*>(ptr)->createRedoAction(static_cast<QObject*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	}
}

void* QUndoGroup_CreateUndoAction(void* ptr, void* parent, struct QtWidgets_PackedString prefix)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoGroup*>(ptr)->createUndoAction(static_cast<QGraphicsObject*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoGroup*>(ptr)->createUndoAction(static_cast<QGraphicsWidget*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoGroup*>(ptr)->createUndoAction(static_cast<QLayout*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoGroup*>(ptr)->createUndoAction(static_cast<QWidget*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else {
		return static_cast<QUndoGroup*>(ptr)->createUndoAction(static_cast<QObject*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	}
}

void QUndoGroup_ConnectIndexChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(int)>(&QUndoGroup::indexChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(int)>(&MyQUndoGroup::Signal_IndexChanged), static_cast<Qt::ConnectionType>(t));
}

void QUndoGroup_DisconnectIndexChanged(void* ptr)
{
	QObject::disconnect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(int)>(&QUndoGroup::indexChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(int)>(&MyQUndoGroup::Signal_IndexChanged));
}

void QUndoGroup_IndexChanged(void* ptr, int idx)
{
	static_cast<QUndoGroup*>(ptr)->indexChanged(idx);
}

char QUndoGroup_IsClean(void* ptr)
{
	return static_cast<QUndoGroup*>(ptr)->isClean();
}

void QUndoGroup_Redo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoGroup*>(ptr), "redo");
}

void QUndoGroup_RedoDefault(void* ptr)
{
		static_cast<QUndoGroup*>(ptr)->QUndoGroup::redo();
}

struct QtWidgets_PackedString QUndoGroup_RedoText(void* ptr)
{
	return ({ QByteArray* tafd4da = new QByteArray(static_cast<QUndoGroup*>(ptr)->redoText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tafd4da->prepend("WHITESPACE").constData()+10), tafd4da->size()-10, tafd4da }; });
}

void QUndoGroup_ConnectRedoTextChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(const QString &)>(&QUndoGroup::redoTextChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(const QString &)>(&MyQUndoGroup::Signal_RedoTextChanged), static_cast<Qt::ConnectionType>(t));
}

void QUndoGroup_DisconnectRedoTextChanged(void* ptr)
{
	QObject::disconnect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(const QString &)>(&QUndoGroup::redoTextChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(const QString &)>(&MyQUndoGroup::Signal_RedoTextChanged));
}

void QUndoGroup_RedoTextChanged(void* ptr, struct QtWidgets_PackedString redoText)
{
	static_cast<QUndoGroup*>(ptr)->redoTextChanged(QString::fromUtf8(redoText.data, redoText.len));
}

void QUndoGroup_RemoveStack(void* ptr, void* stack)
{
	static_cast<QUndoGroup*>(ptr)->removeStack(static_cast<QUndoStack*>(stack));
}

void QUndoGroup_SetActiveStack(void* ptr, void* stack)
{
	QMetaObject::invokeMethod(static_cast<QUndoGroup*>(ptr), "setActiveStack", Q_ARG(QUndoStack*, static_cast<QUndoStack*>(stack)));
}

void QUndoGroup_SetActiveStackDefault(void* ptr, void* stack)
{
		static_cast<QUndoGroup*>(ptr)->QUndoGroup::setActiveStack(static_cast<QUndoStack*>(stack));
}

struct QtWidgets_PackedList QUndoGroup_Stacks(void* ptr)
{
	return ({ QList<QUndoStack *>* tmpValueeb3ecf = new QList<QUndoStack *>(static_cast<QUndoGroup*>(ptr)->stacks()); QtWidgets_PackedList { tmpValueeb3ecf, tmpValueeb3ecf->size() }; });
}

void QUndoGroup_Undo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoGroup*>(ptr), "undo");
}

void QUndoGroup_UndoDefault(void* ptr)
{
		static_cast<QUndoGroup*>(ptr)->QUndoGroup::undo();
}

struct QtWidgets_PackedString QUndoGroup_UndoText(void* ptr)
{
	return ({ QByteArray* t39b3cc = new QByteArray(static_cast<QUndoGroup*>(ptr)->undoText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t39b3cc->prepend("WHITESPACE").constData()+10), t39b3cc->size()-10, t39b3cc }; });
}

void QUndoGroup_ConnectUndoTextChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(const QString &)>(&QUndoGroup::undoTextChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(const QString &)>(&MyQUndoGroup::Signal_UndoTextChanged), static_cast<Qt::ConnectionType>(t));
}

void QUndoGroup_DisconnectUndoTextChanged(void* ptr)
{
	QObject::disconnect(static_cast<QUndoGroup*>(ptr), static_cast<void (QUndoGroup::*)(const QString &)>(&QUndoGroup::undoTextChanged), static_cast<MyQUndoGroup*>(ptr), static_cast<void (MyQUndoGroup::*)(const QString &)>(&MyQUndoGroup::Signal_UndoTextChanged));
}

void QUndoGroup_UndoTextChanged(void* ptr, struct QtWidgets_PackedString undoText)
{
	static_cast<QUndoGroup*>(ptr)->undoTextChanged(QString::fromUtf8(undoText.data, undoText.len));
}

void QUndoGroup_DestroyQUndoGroup(void* ptr)
{
	static_cast<QUndoGroup*>(ptr)->~QUndoGroup();
}

void QUndoGroup_DestroyQUndoGroupDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QUndoGroup___stacks_atList(void* ptr, int i)
{
	return ({QUndoStack * tmp = static_cast<QList<QUndoStack *>*>(ptr)->at(i); if (i == static_cast<QList<QUndoStack *>*>(ptr)->size()-1) { static_cast<QList<QUndoStack *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QUndoGroup___stacks_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QUndoStack *>();
}

void* QUndoGroup___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QUndoGroup___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QUndoGroup___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QUndoGroup___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QUndoGroup___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QUndoGroup___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QUndoGroup___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

void QUndoGroup_DeleteLaterDefault(void* ptr)
{
		static_cast<QUndoGroup*>(ptr)->QUndoGroup::deleteLater();
}

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

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

char QUndoGroup_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QUndoGroup*>(ptr)->QUndoGroup::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QUndoGroup*>(ptr)->QUndoGroup::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QUndoGroup*>(ptr)->QUndoGroup::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QUndoGroup*>(ptr)->QUndoGroup::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QUndoGroup*>(ptr)->QUndoGroup::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQUndoStack: public QUndoStack
{
public:
	MyQUndoStack(QObject *parent = Q_NULLPTR) : QUndoStack(parent) {QUndoStack_QUndoStack_QRegisterMetaType();};
	void Signal_CanRedoChanged(bool canRedo) { callbackQUndoStack_CanRedoChanged(this, canRedo); };
	void Signal_CanUndoChanged(bool canUndo) { callbackQUndoStack_CanUndoChanged(this, canUndo); };
	void Signal_CleanChanged(bool clean) { callbackQUndoStack_CleanChanged(this, clean); };
	void Signal_IndexChanged(int idx) { callbackQUndoStack_IndexChanged(this, idx); };
	void redo() { callbackQUndoStack_Redo(this); };
	void Signal_RedoTextChanged(const QString & redoText) { QByteArray* te82275 = new QByteArray(redoText.toUtf8()); QtWidgets_PackedString redoTextPacked = { const_cast<char*>(te82275->prepend("WHITESPACE").constData()+10), te82275->size()-10, te82275 };callbackQUndoStack_RedoTextChanged(this, redoTextPacked); };
	void resetClean() { callbackQUndoStack_ResetClean(this); };
	void setActive(bool active) { callbackQUndoStack_SetActive(this, active); };
	void setClean() { callbackQUndoStack_SetClean(this); };
	void setIndex(int idx) { callbackQUndoStack_SetIndex(this, idx); };
	void undo() { callbackQUndoStack_Undo(this); };
	void Signal_UndoTextChanged(const QString & undoText) { QByteArray* t66d0aa = new QByteArray(undoText.toUtf8()); QtWidgets_PackedString undoTextPacked = { const_cast<char*>(t66d0aa->prepend("WHITESPACE").constData()+10), t66d0aa->size()-10, t66d0aa };callbackQUndoStack_UndoTextChanged(this, undoTextPacked); };
	 ~MyQUndoStack() { callbackQUndoStack_DestroyQUndoStack(this); };
	void childEvent(QChildEvent * event) { callbackQUndoStack_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQUndoStack_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQUndoStack_CustomEvent(this, event); };
	void deleteLater() { callbackQUndoStack_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQUndoStack_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQUndoStack_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQUndoStack_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQUndoStack_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQUndoStack_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQUndoStack_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQUndoStack_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QUndoStack*)
Q_DECLARE_METATYPE(MyQUndoStack*)

int QUndoStack_QUndoStack_QRegisterMetaType(){qRegisterMetaType<QUndoStack*>(); return qRegisterMetaType<MyQUndoStack*>();}

void* QUndoStack_NewQUndoStack(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQUndoStack(static_cast<QWindow*>(parent));
	} else {
		return new MyQUndoStack(static_cast<QObject*>(parent));
	}
}

void QUndoStack_BeginMacro(void* ptr, struct QtWidgets_PackedString text)
{
	static_cast<QUndoStack*>(ptr)->beginMacro(QString::fromUtf8(text.data, text.len));
}

char QUndoStack_CanRedo(void* ptr)
{
	return static_cast<QUndoStack*>(ptr)->canRedo();
}

void QUndoStack_ConnectCanRedoChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QUndoStack*>(ptr), static_cast<void (QUndoStack::*)(bool)>(&QUndoStack::canRedoChanged), static_cast<MyQUndoStack*>(ptr), static_cast<void (MyQUndoStack::*)(bool)>(&MyQUndoStack::Signal_CanRedoChanged), static_cast<Qt::ConnectionType>(t));
}

void QUndoStack_DisconnectCanRedoChanged(void* ptr)
{
	QObject::disconnect(static_cast<QUndoStack*>(ptr), static_cast<void (QUndoStack::*)(bool)>(&QUndoStack::canRedoChanged), static_cast<MyQUndoStack*>(ptr), static_cast<void (MyQUndoStack::*)(bool)>(&MyQUndoStack::Signal_CanRedoChanged));
}

void QUndoStack_CanRedoChanged(void* ptr, char canRedo)
{
	static_cast<QUndoStack*>(ptr)->canRedoChanged(canRedo != 0);
}

char QUndoStack_CanUndo(void* ptr)
{
	return static_cast<QUndoStack*>(ptr)->canUndo();
}

void QUndoStack_ConnectCanUndoChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QUndoStack*>(ptr), static_cast<void (QUndoStack::*)(bool)>(&QUndoStack::canUndoChanged), static_cast<MyQUndoStack*>(ptr), static_cast<void (MyQUndoStack::*)(bool)>(&MyQUndoStack::Signal_CanUndoChanged), static_cast<Qt::ConnectionType>(t));
}

void QUndoStack_DisconnectCanUndoChanged(void* ptr)
{
	QObject::disconnect(static_cast<QUndoStack*>(ptr), static_cast<void (QUndoStack::*)(bool)>(&QUndoStack::canUndoChanged), static_cast<MyQUndoStack*>(ptr), static_cast<void (MyQUndoStack::*)(bool)>(&MyQUndoStack::Signal_CanUndoChanged));
}

void QUndoStack_CanUndoChanged(void* ptr, char canUndo)
{
	static_cast<QUndoStack*>(ptr)->canUndoChanged(canUndo != 0);
}

void QUndoStack_ConnectCleanChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QUndoStack*>(ptr), static_cast<void (QUndoStack::*)(bool)>(&QUndoStack::cleanChanged), static_cast<MyQUndoStack*>(ptr), static_cast<void (MyQUndoStack::*)(bool)>(&MyQUndoStack::Signal_CleanChanged), static_cast<Qt::ConnectionType>(t));
}

void QUndoStack_DisconnectCleanChanged(void* ptr)
{
	QObject::disconnect(static_cast<QUndoStack*>(ptr), static_cast<void (QUndoStack::*)(bool)>(&QUndoStack::cleanChanged), static_cast<MyQUndoStack*>(ptr), static_cast<void (MyQUndoStack::*)(bool)>(&MyQUndoStack::Signal_CleanChanged));
}

void QUndoStack_CleanChanged(void* ptr, char clean)
{
	static_cast<QUndoStack*>(ptr)->cleanChanged(clean != 0);
}

int QUndoStack_CleanIndex(void* ptr)
{
	return static_cast<QUndoStack*>(ptr)->cleanIndex();
}

void QUndoStack_Clear(void* ptr)
{
	static_cast<QUndoStack*>(ptr)->clear();
}

void* QUndoStack_Command(void* ptr, int index)
{
	return const_cast<QUndoCommand*>(static_cast<QUndoStack*>(ptr)->command(index));
}

int QUndoStack_Count(void* ptr)
{
	return static_cast<QUndoStack*>(ptr)->count();
}

void* QUndoStack_CreateRedoAction(void* ptr, void* parent, struct QtWidgets_PackedString prefix)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoStack*>(ptr)->createRedoAction(static_cast<QGraphicsObject*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoStack*>(ptr)->createRedoAction(static_cast<QGraphicsWidget*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoStack*>(ptr)->createRedoAction(static_cast<QLayout*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoStack*>(ptr)->createRedoAction(static_cast<QWidget*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else {
		return static_cast<QUndoStack*>(ptr)->createRedoAction(static_cast<QObject*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	}
}

void* QUndoStack_CreateUndoAction(void* ptr, void* parent, struct QtWidgets_PackedString prefix)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoStack*>(ptr)->createUndoAction(static_cast<QGraphicsObject*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoStack*>(ptr)->createUndoAction(static_cast<QGraphicsWidget*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoStack*>(ptr)->createUndoAction(static_cast<QLayout*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return static_cast<QUndoStack*>(ptr)->createUndoAction(static_cast<QWidget*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	} else {
		return static_cast<QUndoStack*>(ptr)->createUndoAction(static_cast<QObject*>(parent), QString::fromUtf8(prefix.data, prefix.len));
	}
}

void QUndoStack_EndMacro(void* ptr)
{
	static_cast<QUndoStack*>(ptr)->endMacro();
}

int QUndoStack_Index(void* ptr)
{
	return static_cast<QUndoStack*>(ptr)->index();
}

void QUndoStack_ConnectIndexChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QUndoStack*>(ptr), static_cast<void (QUndoStack::*)(int)>(&QUndoStack::indexChanged), static_cast<MyQUndoStack*>(ptr), static_cast<void (MyQUndoStack::*)(int)>(&MyQUndoStack::Signal_IndexChanged), static_cast<Qt::ConnectionType>(t));
}

void QUndoStack_DisconnectIndexChanged(void* ptr)
{
	QObject::disconnect(static_cast<QUndoStack*>(ptr), static_cast<void (QUndoStack::*)(int)>(&QUndoStack::indexChanged), static_cast<MyQUndoStack*>(ptr), static_cast<void (MyQUndoStack::*)(int)>(&MyQUndoStack::Signal_IndexChanged));
}

void QUndoStack_IndexChanged(void* ptr, int idx)
{
	static_cast<QUndoStack*>(ptr)->indexChanged(idx);
}

char QUndoStack_IsActive(void* ptr)
{
	return static_cast<QUndoStack*>(ptr)->isActive();
}

char QUndoStack_IsClean(void* ptr)
{
	return static_cast<QUndoStack*>(ptr)->isClean();
}

void QUndoStack_Push(void* ptr, void* cmd)
{
	static_cast<QUndoStack*>(ptr)->push(static_cast<QUndoCommand*>(cmd));
}

void QUndoStack_Redo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoStack*>(ptr), "redo");
}

void QUndoStack_RedoDefault(void* ptr)
{
		static_cast<QUndoStack*>(ptr)->QUndoStack::redo();
}

struct QtWidgets_PackedString QUndoStack_RedoText(void* ptr)
{
	return ({ QByteArray* t792834 = new QByteArray(static_cast<QUndoStack*>(ptr)->redoText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t792834->prepend("WHITESPACE").constData()+10), t792834->size()-10, t792834 }; });
}

void QUndoStack_ConnectRedoTextChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QUndoStack*>(ptr), static_cast<void (QUndoStack::*)(const QString &)>(&QUndoStack::redoTextChanged), static_cast<MyQUndoStack*>(ptr), static_cast<void (MyQUndoStack::*)(const QString &)>(&MyQUndoStack::Signal_RedoTextChanged), static_cast<Qt::ConnectionType>(t));
}

void QUndoStack_DisconnectRedoTextChanged(void* ptr)
{
	QObject::disconnect(static_cast<QUndoStack*>(ptr), static_cast<void (QUndoStack::*)(const QString &)>(&QUndoStack::redoTextChanged), static_cast<MyQUndoStack*>(ptr), static_cast<void (MyQUndoStack::*)(const QString &)>(&MyQUndoStack::Signal_RedoTextChanged));
}

void QUndoStack_RedoTextChanged(void* ptr, struct QtWidgets_PackedString redoText)
{
	static_cast<QUndoStack*>(ptr)->redoTextChanged(QString::fromUtf8(redoText.data, redoText.len));
}

void QUndoStack_ResetClean(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoStack*>(ptr), "resetClean");
}

void QUndoStack_ResetCleanDefault(void* ptr)
{
		static_cast<QUndoStack*>(ptr)->QUndoStack::resetClean();
}

void QUndoStack_SetActive(void* ptr, char active)
{
	QMetaObject::invokeMethod(static_cast<QUndoStack*>(ptr), "setActive", Q_ARG(bool, active != 0));
}

void QUndoStack_SetActiveDefault(void* ptr, char active)
{
		static_cast<QUndoStack*>(ptr)->QUndoStack::setActive(active != 0);
}

void QUndoStack_SetClean(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoStack*>(ptr), "setClean");
}

void QUndoStack_SetCleanDefault(void* ptr)
{
		static_cast<QUndoStack*>(ptr)->QUndoStack::setClean();
}

void QUndoStack_SetIndex(void* ptr, int idx)
{
	QMetaObject::invokeMethod(static_cast<QUndoStack*>(ptr), "setIndex", Q_ARG(int, idx));
}

void QUndoStack_SetIndexDefault(void* ptr, int idx)
{
		static_cast<QUndoStack*>(ptr)->QUndoStack::setIndex(idx);
}

void QUndoStack_SetUndoLimit(void* ptr, int limit)
{
	static_cast<QUndoStack*>(ptr)->setUndoLimit(limit);
}

struct QtWidgets_PackedString QUndoStack_Text(void* ptr, int idx)
{
	return ({ QByteArray* t2bc9dc = new QByteArray(static_cast<QUndoStack*>(ptr)->text(idx).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t2bc9dc->prepend("WHITESPACE").constData()+10), t2bc9dc->size()-10, t2bc9dc }; });
}

void QUndoStack_Undo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoStack*>(ptr), "undo");
}

void QUndoStack_UndoDefault(void* ptr)
{
		static_cast<QUndoStack*>(ptr)->QUndoStack::undo();
}

int QUndoStack_UndoLimit(void* ptr)
{
	return static_cast<QUndoStack*>(ptr)->undoLimit();
}

struct QtWidgets_PackedString QUndoStack_UndoText(void* ptr)
{
	return ({ QByteArray* t399a88 = new QByteArray(static_cast<QUndoStack*>(ptr)->undoText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t399a88->prepend("WHITESPACE").constData()+10), t399a88->size()-10, t399a88 }; });
}

void QUndoStack_ConnectUndoTextChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QUndoStack*>(ptr), static_cast<void (QUndoStack::*)(const QString &)>(&QUndoStack::undoTextChanged), static_cast<MyQUndoStack*>(ptr), static_cast<void (MyQUndoStack::*)(const QString &)>(&MyQUndoStack::Signal_UndoTextChanged), static_cast<Qt::ConnectionType>(t));
}

void QUndoStack_DisconnectUndoTextChanged(void* ptr)
{
	QObject::disconnect(static_cast<QUndoStack*>(ptr), static_cast<void (QUndoStack::*)(const QString &)>(&QUndoStack::undoTextChanged), static_cast<MyQUndoStack*>(ptr), static_cast<void (MyQUndoStack::*)(const QString &)>(&MyQUndoStack::Signal_UndoTextChanged));
}

void QUndoStack_UndoTextChanged(void* ptr, struct QtWidgets_PackedString undoText)
{
	static_cast<QUndoStack*>(ptr)->undoTextChanged(QString::fromUtf8(undoText.data, undoText.len));
}

void QUndoStack_DestroyQUndoStack(void* ptr)
{
	static_cast<QUndoStack*>(ptr)->~QUndoStack();
}

void QUndoStack_DestroyQUndoStackDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QUndoStack___children_atList(void* ptr, int i)
{
	return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QUndoStack___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QUndoStack___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QUndoStack___findChildren_atList(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QUndoStack___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QUndoStack___findChildren_atList3(void* ptr, int i)
{
	return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QUndoStack___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

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

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

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

void QUndoStack_DeleteLaterDefault(void* ptr)
{
		static_cast<QUndoStack*>(ptr)->QUndoStack::deleteLater();
}

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

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

char QUndoStack_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QUndoStack*>(ptr)->QUndoStack::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QUndoStack*>(ptr)->QUndoStack::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QUndoStack*>(ptr)->QUndoStack::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QUndoStack*>(ptr)->QUndoStack::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QUndoStack*>(ptr)->QUndoStack::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

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

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

class MyQUndoView: public QUndoView
{
public:
	MyQUndoView(QWidget *parent = Q_NULLPTR) : QUndoView(parent) {QUndoView_QUndoView_QRegisterMetaType();};
	MyQUndoView(QUndoStack *stack, QWidget *parent = Q_NULLPTR) : QUndoView(stack, parent) {QUndoView_QUndoView_QRegisterMetaType();};
	MyQUndoView(QUndoGroup *group, QWidget *parent = Q_NULLPTR) : QUndoView(group, parent) {QUndoView_QUndoView_QRegisterMetaType();};
	void setGroup(QUndoGroup * group) { callbackQUndoView_SetGroup(this, group); };
	void setStack(QUndoStack * stack) { callbackQUndoView_SetStack(this, stack); };
	 ~MyQUndoView() { callbackQUndoView_DestroyQUndoView(this); };
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQListView_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	void dataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQListView_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtWidgets_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQWidget_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQWidget_DragMoveEvent(this, e); };
	void dropEvent(QDropEvent * e) { callbackQWidget_DropEvent(this, e); };
	bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
	int horizontalOffset() const { return callbackQListView_HorizontalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QModelIndex indexAt(const QPoint & p) const { return *static_cast<QModelIndex*>(callbackQListView_IndexAt(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&p))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQListView_IsIndexHidden(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index)) != 0; };
	void mouseMoveEvent(QMouseEvent * e) { callbackQWidget_MouseMoveEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQWidget_MouseReleaseEvent(this, e); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQListView_MoveCursor(this, cursorAction, modifiers)); };
	void paintEvent(QPaintEvent * e) { callbackQWidget_PaintEvent(this, e); };
	void resizeEvent(QResizeEvent * e) { callbackQWidget_ResizeEvent(this, e); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQListView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQListView_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQListView_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	QList<QModelIndex> selectedIndexes() const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemView_SelectedIndexes(const_cast<void*>(static_cast<const void*>(this)))); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQListView_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQListView_SetSelection(this, const_cast<QRect*>(&rect), command); };
	void startDrag(Qt::DropActions supportedActions) { callbackQAbstractItemView_StartDrag(this, supportedActions); };
	void timerEvent(QTimerEvent * e) { callbackQWidget_TimerEvent(this, e); };
	void updateGeometries() { callbackQListView_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQListView_VerticalOffset(const_cast<void*>(static_cast<const void*>(this))); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQAbstractItemView_ViewOptions(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQListView_VisualRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQListView_VisualRegionForSelection(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&selection))); };
	void wheelEvent(QWheelEvent * e) { callbackQWidget_WheelEvent(this, e); };
	void Signal_Activated(const QModelIndex & index) { callbackQAbstractItemView_Activated(this, const_cast<QModelIndex*>(&index)); };
	void clearSelection() { callbackQAbstractItemView_ClearSelection(this); };
	void Signal_Clicked(const QModelIndex & index) { callbackQAbstractItemView_Clicked(this, const_cast<QModelIndex*>(&index)); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQAbstractItemView_CommitData(this, editor); };
	void Signal_DoubleClicked(const QModelIndex & index) { callbackQAbstractItemView_DoubleClicked(this, const_cast<QModelIndex*>(&index)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQAbstractItemView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQAbstractItemView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQAbstractItemView_EditorDestroyed(this, editor); };
	void Signal_Entered(const QModelIndex & index) { callbackQAbstractItemView_Entered(this, const_cast<QModelIndex*>(&index)); };
	bool eventFilter(QObject * object, QEvent * event) { return callbackQWidget_EventFilter(this, object, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void Signal_IconSizeChanged(const QSize & size) { callbackQAbstractItemView_IconSizeChanged(this, const_cast<QSize*>(&size)); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { QByteArray* t3559d7 = new QByteArray(search.toUtf8()); QtWidgets_PackedString searchPacked = { const_cast<char*>(t3559d7->prepend("WHITESPACE").constData()+10), t3559d7->size()-10, t3559d7 };callbackQAbstractItemView_KeyboardSearch(this, searchPacked); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void Signal_Pressed(const QModelIndex & index) { callbackQAbstractItemView_Pressed(this, const_cast<QModelIndex*>(&index)); };
	void reset() { callbackQAbstractItemView_Reset(this); };
	void scrollToBottom() { callbackQAbstractItemView_ScrollToBottom(this); };
	void scrollToTop() { callbackQAbstractItemView_ScrollToTop(this); };
	void selectAll() { callbackQAbstractItemView_SelectAll(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQAbstractItemView_SelectionCommand(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQAbstractItemView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	void setModel(QAbstractItemModel * model) { callbackQAbstractItemView_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQAbstractItemView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQAbstractItemView_SetSelectionModel(this, selectionModel); };
	int sizeHintForColumn(int column) const { return callbackQAbstractItemView_SizeHintForColumn(const_cast<void*>(static_cast<const void*>(this)), column); };
	int sizeHintForRow(int row) const { return callbackQAbstractItemView_SizeHintForRow(const_cast<void*>(static_cast<const void*>(this)), row); };
	void update(const QModelIndex & index) { callbackQAbstractItemView_Update(this, const_cast<QModelIndex*>(&index)); };
	void Signal_ViewportEntered() { callbackQAbstractItemView_ViewportEntered(this); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
};

Q_DECLARE_METATYPE(QUndoView*)
Q_DECLARE_METATYPE(MyQUndoView*)

int QUndoView_QUndoView_QRegisterMetaType(){qRegisterMetaType<QUndoView*>(); return qRegisterMetaType<MyQUndoView*>();}

void* QUndoView_NewQUndoView(void* parent)
{
		return new MyQUndoView(static_cast<QWidget*>(parent));
}

void* QUndoView_NewQUndoView2(void* stack, void* parent)
{
		return new MyQUndoView(static_cast<QUndoStack*>(stack), static_cast<QWidget*>(parent));
}

void* QUndoView_NewQUndoView3(void* group, void* parent)
{
		return new MyQUndoView(static_cast<QUndoGroup*>(group), static_cast<QWidget*>(parent));
}

void* QUndoView_CleanIcon(void* ptr)
{
	return new QIcon(static_cast<QUndoView*>(ptr)->cleanIcon());
}

struct QtWidgets_PackedString QUndoView_EmptyLabel(void* ptr)
{
	return ({ QByteArray* tc33a41 = new QByteArray(static_cast<QUndoView*>(ptr)->emptyLabel().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tc33a41->prepend("WHITESPACE").constData()+10), tc33a41->size()-10, tc33a41 }; });
}

void* QUndoView_Group(void* ptr)
{
	return static_cast<QUndoView*>(ptr)->group();
}

void QUndoView_SetCleanIcon(void* ptr, void* icon)
{
	static_cast<QUndoView*>(ptr)->setCleanIcon(*static_cast<QIcon*>(icon));
}

void QUndoView_SetEmptyLabel(void* ptr, struct QtWidgets_PackedString label)
{
	static_cast<QUndoView*>(ptr)->setEmptyLabel(QString::fromUtf8(label.data, label.len));
}

void QUndoView_SetGroup(void* ptr, void* group)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setGroup", Q_ARG(QUndoGroup*, static_cast<QUndoGroup*>(group)));
}

void QUndoView_SetGroupDefault(void* ptr, void* group)
{
		static_cast<QUndoView*>(ptr)->QUndoView::setGroup(static_cast<QUndoGroup*>(group));
}

void QUndoView_SetStack(void* ptr, void* stack)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setStack", Q_ARG(QUndoStack*, static_cast<QUndoStack*>(stack)));
}

void QUndoView_SetStackDefault(void* ptr, void* stack)
{
		static_cast<QUndoView*>(ptr)->QUndoView::setStack(static_cast<QUndoStack*>(stack));
}

void* QUndoView_Stack(void* ptr)
{
	return static_cast<QUndoView*>(ptr)->stack();
}

void QUndoView_DestroyQUndoView(void* ptr)
{
	static_cast<QUndoView*>(ptr)->~QUndoView();
}

void QUndoView_DestroyQUndoViewDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQVBoxLayout: public QVBoxLayout
{
public:
	MyQVBoxLayout() : QVBoxLayout() {QVBoxLayout_QVBoxLayout_QRegisterMetaType();};
	MyQVBoxLayout(QWidget *parent) : QVBoxLayout(parent) {QVBoxLayout_QVBoxLayout_QRegisterMetaType();};
	 ~MyQVBoxLayout() { callbackQVBoxLayout_DestroyQVBoxLayout(this); };
	void addItem(QLayoutItem * item) { callbackQBoxLayout_AddItem(this, item); };
	int count() const { return callbackQBoxLayout_Count(const_cast<void*>(static_cast<const void*>(this))); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQLayout_ExpandingDirections(const_cast<void*>(static_cast<const void*>(this)))); };
	bool hasHeightForWidth() const { return callbackQLayoutItem_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQLayoutItem_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void invalidate() { callbackQLayoutItem_Invalidate(this); };
	QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQBoxLayout_ItemAt(const_cast<void*>(static_cast<const void*>(this)), index)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQLayout_MaximumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	int minimumHeightForWidth(int w) const { return callbackQLayoutItem_MinimumHeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQLayout_MinimumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	void setGeometry(const QRect & r) { callbackQLayout_SetGeometry(this, const_cast<QRect*>(&r)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQBoxLayout_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQBoxLayout_TakeAt(this, index)); };
	void childEvent(QChildEvent * e) { callbackQLayout_ChildEvent(this, e); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayoutItem_ControlTypes(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQLayout_Geometry(const_cast<void*>(static_cast<const void*>(this)))); };
	int indexOf(QWidget * widget) const { return callbackQLayout_IndexOf(const_cast<void*>(static_cast<const void*>(this)), widget); };
	bool isEmpty() const { return callbackQLayout_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QLayout * layout() { return static_cast<QLayout*>(callbackQLayoutItem_Layout(this)); };
	void connectNotify(const QMetaMethod & sign) { callbackQLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQLayout_CustomEvent(this, event); };
	void deleteLater() { callbackQLayout_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQLayout_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQLayout_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQLayout_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLayout_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQLayout_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQLayout_TimerEvent(this, event); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayoutItem_SpacerItem(this)); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQLayoutItem_Widget(this)); };
};

Q_DECLARE_METATYPE(QVBoxLayout*)
Q_DECLARE_METATYPE(MyQVBoxLayout*)

int QVBoxLayout_QVBoxLayout_QRegisterMetaType(){qRegisterMetaType<QVBoxLayout*>(); return qRegisterMetaType<MyQVBoxLayout*>();}

void* QVBoxLayout_NewQVBoxLayout()
{
	return new MyQVBoxLayout();
}

void* QVBoxLayout_NewQVBoxLayout2(void* parent)
{
		return new MyQVBoxLayout(static_cast<QWidget*>(parent));
}

void QVBoxLayout_DestroyQVBoxLayout(void* ptr)
{
	static_cast<QVBoxLayout*>(ptr)->~QVBoxLayout();
}

void QVBoxLayout_DestroyQVBoxLayoutDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QWhatsThis_QWhatsThis_CreateAction(void* parent)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return QWhatsThis::createAction(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return QWhatsThis::createAction(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return QWhatsThis::createAction(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return QWhatsThis::createAction(static_cast<QWidget*>(parent));
	} else {
		return QWhatsThis::createAction(static_cast<QObject*>(parent));
	}
}

void QWhatsThis_QWhatsThis_EnterWhatsThisMode()
{
	QWhatsThis::enterWhatsThisMode();
}

void QWhatsThis_QWhatsThis_HideText()
{
	QWhatsThis::hideText();
}

char QWhatsThis_QWhatsThis_InWhatsThisMode()
{
	return QWhatsThis::inWhatsThisMode();
}

void QWhatsThis_QWhatsThis_LeaveWhatsThisMode()
{
	QWhatsThis::leaveWhatsThisMode();
}

void QWhatsThis_QWhatsThis_ShowText(void* pos, struct QtWidgets_PackedString text, void* w)
{
		QWhatsThis::showText(*static_cast<QPoint*>(pos), QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(w));
}

class MyQWidget: public QWidget
{
public:
	MyQWidget(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QWidget(parent, ff) {QWidget_QWidget_QRegisterMetaType();};
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	 ~MyQWidget() { callbackQWidget_DestroyQWidget(this); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QWidget*)
Q_DECLARE_METATYPE(MyQWidget*)

int QWidget_QWidget_QRegisterMetaType(){qRegisterMetaType<QWidget*>(); return qRegisterMetaType<MyQWidget*>();}

void* QWidget_NewQWidget(void* parent, long long ff)
{
	return new MyQWidget(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}

char QWidget_AcceptDrops(void* ptr)
{
		return static_cast<QWidget*>(ptr)->acceptDrops();
}

struct QtWidgets_PackedString QWidget_AccessibleDescription(void* ptr)
{
		return ({ QByteArray* tb88bc9 = new QByteArray(static_cast<QWidget*>(ptr)->accessibleDescription().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tb88bc9->prepend("WHITESPACE").constData()+10), tb88bc9->size()-10, tb88bc9 }; });
}

struct QtWidgets_PackedString QWidget_AccessibleName(void* ptr)
{
		return ({ QByteArray* t32cbb8 = new QByteArray(static_cast<QWidget*>(ptr)->accessibleName().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t32cbb8->prepend("WHITESPACE").constData()+10), t32cbb8->size()-10, t32cbb8 }; });
}

void QWidget_ActionEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QWidget_ActionEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::actionEvent(static_cast<QActionEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::actionEvent(static_cast<QActionEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::actionEvent(static_cast<QActionEvent*>(event));
	}
}

struct QtWidgets_PackedList QWidget_Actions(void* ptr)
{
		return ({ QList<QAction *>* tmpValue268e58 = new QList<QAction *>(static_cast<QWidget*>(ptr)->actions()); QtWidgets_PackedList { tmpValue268e58, tmpValue268e58->size() }; });
}

void QWidget_ActivateWindow(void* ptr)
{
		static_cast<QWidget*>(ptr)->activateWindow();
}

void QWidget_AddAction(void* ptr, void* action)
{
		static_cast<QWidget*>(ptr)->addAction(static_cast<QAction*>(action));
}

void QWidget_AddActions(void* ptr, void* actions)
{
		static_cast<QWidget*>(ptr)->addActions(({ QList<QAction *>* tmpP = static_cast<QList<QAction *>*>(actions); QList<QAction *> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
}

void QWidget_AdjustSize(void* ptr)
{
		static_cast<QWidget*>(ptr)->adjustSize();
}

char QWidget_AutoFillBackground(void* ptr)
{
		return static_cast<QWidget*>(ptr)->autoFillBackground();
}

long long QWidget_BackgroundRole(void* ptr)
{
		return static_cast<QWidget*>(ptr)->backgroundRole();
}

void* QWidget_BackingStore(void* ptr)
{
		return static_cast<QWidget*>(ptr)->backingStore();
}

void* QWidget_BaseSize(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->baseSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QWidget_ChangeEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QWidget_ChangeEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::changeEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::changeEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::changeEvent(static_cast<QEvent*>(event));
	}
}

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

void* QWidget_ChildAt2(void* ptr, void* p)
{
		return static_cast<QWidget*>(ptr)->childAt(*static_cast<QPoint*>(p));
}

void* QWidget_ChildrenRect(void* ptr)
{
		return ({ QRect tmpValue = static_cast<QWidget*>(ptr)->childrenRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QWidget_ChildrenRegion(void* ptr)
{
		return new QRegion(static_cast<QWidget*>(ptr)->childrenRegion());
}

void QWidget_ClearFocus(void* ptr)
{
		static_cast<QWidget*>(ptr)->clearFocus();
}

void QWidget_ClearMask(void* ptr)
{
		static_cast<QWidget*>(ptr)->clearMask();
}

char QWidget_Close(void* ptr)
{
		bool returnArg;
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QWidget_CloseDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizardPage*>(ptr)->QWizardPage::close();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBar*>(ptr)->QToolBar::close();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStatusBar*>(ptr)->QStatusBar::close();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::close();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplashScreen*>(ptr)->QSplashScreen::close();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSizeGrip*>(ptr)->QSizeGrip::close();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::close();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenuBar*>(ptr)->QMenuBar::close();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenu*>(ptr)->QMenu::close();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::close();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMainWindow*>(ptr)->QMainWindow::close();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::close();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLineEdit*>(ptr)->QLineEdit::close();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGroupBox*>(ptr)->QGroupBox::close();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressBar*>(ptr)->QProgressBar::close();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFocusFrame*>(ptr)->QFocusFrame::close();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDockWidget*>(ptr)->QDockWidget::close();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::close();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::close();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontComboBox*>(ptr)->QFontComboBox::close();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QComboBox*>(ptr)->QComboBox::close();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizard*>(ptr)->QWizard::close();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMessageBox*>(ptr)->QMessageBox::close();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QInputDialog*>(ptr)->QInputDialog::close();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressDialog*>(ptr)->QProgressDialog::close();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontDialog*>(ptr)->QFontDialog::close();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFileDialog*>(ptr)->QFileDialog::close();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QErrorMessage*>(ptr)->QErrorMessage::close();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColorDialog*>(ptr)->QColorDialog::close();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialog*>(ptr)->QDialog::close();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::close();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBox*>(ptr)->QToolBox::close();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedWidget*>(ptr)->QStackedWidget::close();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitter*>(ptr)->QSplitter::close();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLCDNumber*>(ptr)->QLCDNumber::close();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLabel*>(ptr)->QLabel::close();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::close();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextBrowser*>(ptr)->QTextBrowser::close();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextEdit*>(ptr)->QTextEdit::close();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiArea*>(ptr)->QMdiArea::close();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsView*>(ptr)->QGraphicsView::close();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollArea*>(ptr)->QScrollArea::close();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::close();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeView*>(ptr)->QTreeView::close();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::close();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableView*>(ptr)->QTableView::close();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::close();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::close();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListView*>(ptr)->QListView::close();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHeaderView*>(ptr)->QHeaderView::close();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColumnView*>(ptr)->QColumnView::close();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::close();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::close();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFrame*>(ptr)->QFrame::close();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRubberBand*>(ptr)->QRubberBand::close();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabBar*>(ptr)->QTabBar::close();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollBar*>(ptr)->QScrollBar::close();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDial*>(ptr)->QDial::close();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSlider*>(ptr)->QSlider::close();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::close();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::close();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSpinBox*>(ptr)->QSpinBox::close();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateEdit*>(ptr)->QDateEdit::close();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTimeEdit*>(ptr)->QTimeEdit::close();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::close();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::close();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabWidget*>(ptr)->QTabWidget::close();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolButton*>(ptr)->QToolButton::close();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioButton*>(ptr)->QRadioButton::close();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::close();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPushButton*>(ptr)->QPushButton::close();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCheckBox*>(ptr)->QCheckBox::close();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractButton*>(ptr)->QAbstractButton::close();
	} else {
		return static_cast<QWidget*>(ptr)->QWidget::close();
	}
}

void QWidget_CloseEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QWidget_CloseEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::closeEvent(static_cast<QCloseEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::closeEvent(static_cast<QCloseEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::closeEvent(static_cast<QCloseEvent*>(event));
	}
}

void* QWidget_ContentsMargins(void* ptr)
{
		return ({ QMargins tmpValue = static_cast<QWidget*>(ptr)->contentsMargins(); new QMargins(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}

void* QWidget_ContentsRect(void* ptr)
{
		return ({ QRect tmpValue = static_cast<QWidget*>(ptr)->contentsRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QWidget_ContextMenuEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QWidget_ContextMenuEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
	}
}

long long QWidget_ContextMenuPolicy(void* ptr)
{
		return static_cast<QWidget*>(ptr)->contextMenuPolicy();
}

void QWidget_Create(void* ptr, uintptr_t window, char initializeWindow, char destroyOldWindow)
{
		static_cast<QWidget*>(ptr)->create(window, initializeWindow != 0, destroyOldWindow != 0);
}

void* QWidget_QWidget_CreateWindowContainer(void* window, void* parent, long long flags)
{
		return QWidget::createWindowContainer(static_cast<QWindow*>(window), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}

void* QWidget_Cursor(void* ptr)
{
		return new QCursor(static_cast<QWidget*>(ptr)->cursor());
}

void QWidget_ConnectCustomContextMenuRequested(void* ptr, long long t)
{
	QObject::connect(static_cast<QWidget*>(ptr), static_cast<void (QWidget::*)(const QPoint &)>(&QWidget::customContextMenuRequested), static_cast<MyQWidget*>(ptr), static_cast<void (MyQWidget::*)(const QPoint &)>(&MyQWidget::Signal_CustomContextMenuRequested), static_cast<Qt::ConnectionType>(t));
}

void QWidget_DisconnectCustomContextMenuRequested(void* ptr)
{
	QObject::disconnect(static_cast<QWidget*>(ptr), static_cast<void (QWidget::*)(const QPoint &)>(&QWidget::customContextMenuRequested), static_cast<MyQWidget*>(ptr), static_cast<void (MyQWidget::*)(const QPoint &)>(&MyQWidget::Signal_CustomContextMenuRequested));
}

void QWidget_CustomContextMenuRequested(void* ptr, void* pos)
{
		static_cast<QWidget*>(ptr)->customContextMenuRequested(*static_cast<QPoint*>(pos));
}

void QWidget_Destroy(void* ptr, char destroyWindow, char destroySubWindows)
{
		static_cast<QWidget*>(ptr)->destroy(destroyWindow != 0, destroySubWindows != 0);
}

void QWidget_DragEnterEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QWidget_DragEnterEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
	}
}

void QWidget_DragLeaveEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QWidget_DragLeaveEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
	}
}

void QWidget_DragMoveEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QWidget_DragMoveEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
	}
}

void QWidget_DropEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QWidget_DropEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::dropEvent(static_cast<QDropEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::dropEvent(static_cast<QDropEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::dropEvent(static_cast<QDropEvent*>(event));
	}
}

uintptr_t QWidget_EffectiveWinId(void* ptr)
{
		return static_cast<QWidget*>(ptr)->effectiveWinId();
}

void QWidget_EnsurePolished(void* ptr)
{
		static_cast<QWidget*>(ptr)->ensurePolished();
}

void QWidget_EnterEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QWidget_EnterEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::enterEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::enterEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::enterEvent(static_cast<QEvent*>(event));
	}
}

char QWidget_Event(void* ptr, void* event)
{
		return static_cast<QWidget*>(ptr)->event(static_cast<QEvent*>(event));
}

char QWidget_EventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizardPage*>(ptr)->QWizardPage::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBar*>(ptr)->QToolBar::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStatusBar*>(ptr)->QStatusBar::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplashScreen*>(ptr)->QSplashScreen::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSizeGrip*>(ptr)->QSizeGrip::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenuBar*>(ptr)->QMenuBar::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenu*>(ptr)->QMenu::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMainWindow*>(ptr)->QMainWindow::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLineEdit*>(ptr)->QLineEdit::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGroupBox*>(ptr)->QGroupBox::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressBar*>(ptr)->QProgressBar::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFocusFrame*>(ptr)->QFocusFrame::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDockWidget*>(ptr)->QDockWidget::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontComboBox*>(ptr)->QFontComboBox::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QComboBox*>(ptr)->QComboBox::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizard*>(ptr)->QWizard::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMessageBox*>(ptr)->QMessageBox::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QInputDialog*>(ptr)->QInputDialog::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressDialog*>(ptr)->QProgressDialog::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontDialog*>(ptr)->QFontDialog::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFileDialog*>(ptr)->QFileDialog::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QErrorMessage*>(ptr)->QErrorMessage::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColorDialog*>(ptr)->QColorDialog::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialog*>(ptr)->QDialog::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBox*>(ptr)->QToolBox::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedWidget*>(ptr)->QStackedWidget::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitter*>(ptr)->QSplitter::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLCDNumber*>(ptr)->QLCDNumber::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLabel*>(ptr)->QLabel::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextBrowser*>(ptr)->QTextBrowser::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextEdit*>(ptr)->QTextEdit::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiArea*>(ptr)->QMdiArea::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsView*>(ptr)->QGraphicsView::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollArea*>(ptr)->QScrollArea::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeView*>(ptr)->QTreeView::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableView*>(ptr)->QTableView::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListView*>(ptr)->QListView::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHeaderView*>(ptr)->QHeaderView::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColumnView*>(ptr)->QColumnView::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFrame*>(ptr)->QFrame::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRubberBand*>(ptr)->QRubberBand::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabBar*>(ptr)->QTabBar::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollBar*>(ptr)->QScrollBar::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDial*>(ptr)->QDial::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSlider*>(ptr)->QSlider::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSpinBox*>(ptr)->QSpinBox::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateEdit*>(ptr)->QDateEdit::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTimeEdit*>(ptr)->QTimeEdit::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabWidget*>(ptr)->QTabWidget::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolButton*>(ptr)->QToolButton::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioButton*>(ptr)->QRadioButton::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPushButton*>(ptr)->QPushButton::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCheckBox*>(ptr)->QCheckBox::event(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractButton*>(ptr)->QAbstractButton::event(static_cast<QEvent*>(event));
	} else {
		return static_cast<QWidget*>(ptr)->QWidget::event(static_cast<QEvent*>(event));
	}
}

void* QWidget_QWidget_Find(uintptr_t id)
{
		return QWidget::find(id);
}

void QWidget_FocusInEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QWidget_FocusInEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::focusInEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::focusInEvent(static_cast<QFocusEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::focusInEvent(static_cast<QFocusEvent*>(event));
	}
}

char QWidget_FocusNextChild(void* ptr)
{
		return static_cast<QWidget*>(ptr)->focusNextChild();
}

char QWidget_FocusNextPrevChild(void* ptr, char next)
{
		return static_cast<QWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizardPage*>(ptr)->QWizardPage::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBar*>(ptr)->QToolBar::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStatusBar*>(ptr)->QStatusBar::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplashScreen*>(ptr)->QSplashScreen::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSizeGrip*>(ptr)->QSizeGrip::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenuBar*>(ptr)->QMenuBar::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenu*>(ptr)->QMenu::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMainWindow*>(ptr)->QMainWindow::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLineEdit*>(ptr)->QLineEdit::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGroupBox*>(ptr)->QGroupBox::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressBar*>(ptr)->QProgressBar::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFocusFrame*>(ptr)->QFocusFrame::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDockWidget*>(ptr)->QDockWidget::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontComboBox*>(ptr)->QFontComboBox::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QComboBox*>(ptr)->QComboBox::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizard*>(ptr)->QWizard::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMessageBox*>(ptr)->QMessageBox::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QInputDialog*>(ptr)->QInputDialog::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressDialog*>(ptr)->QProgressDialog::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontDialog*>(ptr)->QFontDialog::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFileDialog*>(ptr)->QFileDialog::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QErrorMessage*>(ptr)->QErrorMessage::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColorDialog*>(ptr)->QColorDialog::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialog*>(ptr)->QDialog::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBox*>(ptr)->QToolBox::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedWidget*>(ptr)->QStackedWidget::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitter*>(ptr)->QSplitter::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLCDNumber*>(ptr)->QLCDNumber::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLabel*>(ptr)->QLabel::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextBrowser*>(ptr)->QTextBrowser::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextEdit*>(ptr)->QTextEdit::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiArea*>(ptr)->QMdiArea::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsView*>(ptr)->QGraphicsView::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollArea*>(ptr)->QScrollArea::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeView*>(ptr)->QTreeView::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableView*>(ptr)->QTableView::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListView*>(ptr)->QListView::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHeaderView*>(ptr)->QHeaderView::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColumnView*>(ptr)->QColumnView::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFrame*>(ptr)->QFrame::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRubberBand*>(ptr)->QRubberBand::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabBar*>(ptr)->QTabBar::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollBar*>(ptr)->QScrollBar::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDial*>(ptr)->QDial::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSlider*>(ptr)->QSlider::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSpinBox*>(ptr)->QSpinBox::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateEdit*>(ptr)->QDateEdit::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTimeEdit*>(ptr)->QTimeEdit::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabWidget*>(ptr)->QTabWidget::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolButton*>(ptr)->QToolButton::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioButton*>(ptr)->QRadioButton::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPushButton*>(ptr)->QPushButton::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCheckBox*>(ptr)->QCheckBox::focusNextPrevChild(next != 0);
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractButton*>(ptr)->QAbstractButton::focusNextPrevChild(next != 0);
	} else {
		return static_cast<QWidget*>(ptr)->QWidget::focusNextPrevChild(next != 0);
	}
}

void QWidget_FocusOutEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QWidget_FocusOutEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::focusOutEvent(static_cast<QFocusEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
	}
}

long long QWidget_FocusPolicy(void* ptr)
{
		return static_cast<QWidget*>(ptr)->focusPolicy();
}

char QWidget_FocusPreviousChild(void* ptr)
{
		return static_cast<QWidget*>(ptr)->focusPreviousChild();
}

void* QWidget_FocusProxy(void* ptr)
{
		return static_cast<QWidget*>(ptr)->focusProxy();
}

void* QWidget_FocusWidget(void* ptr)
{
		return static_cast<QWidget*>(ptr)->focusWidget();
}

void* QWidget_Font(void* ptr)
{
		return const_cast<QFont*>(&static_cast<QWidget*>(ptr)->font());
}

void* QWidget_FontInfo(void* ptr)
{
		return new QFontInfo(static_cast<QWidget*>(ptr)->fontInfo());
}

void* QWidget_FontMetrics(void* ptr)
{
		return new QFontMetrics(static_cast<QWidget*>(ptr)->fontMetrics());
}

long long QWidget_ForegroundRole(void* ptr)
{
		return static_cast<QWidget*>(ptr)->foregroundRole();
}

void* QWidget_FrameGeometry(void* ptr)
{
		return ({ QRect tmpValue = static_cast<QWidget*>(ptr)->frameGeometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QWidget_FrameSize(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->frameSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWidget_Geometry(void* ptr)
{
		return const_cast<QRect*>(&static_cast<QWidget*>(ptr)->geometry());
}

void QWidget_GetContentsMargins(void* ptr, int left, int top, int right, int bottom)
{
		static_cast<QWidget*>(ptr)->getContentsMargins(&left, &top, &right, &bottom);
}

void* QWidget_Grab(void* ptr, void* rectangle)
{
		return new QPixmap(static_cast<QWidget*>(ptr)->grab(*static_cast<QRect*>(rectangle)));
}

void QWidget_GrabGesture(void* ptr, long long gesture, long long flags)
{
		static_cast<QWidget*>(ptr)->grabGesture(static_cast<Qt::GestureType>(gesture), static_cast<Qt::GestureFlag>(flags));
}

void QWidget_GrabKeyboard(void* ptr)
{
		static_cast<QWidget*>(ptr)->grabKeyboard();
}

void QWidget_GrabMouse(void* ptr)
{
		static_cast<QWidget*>(ptr)->grabMouse();
}

void QWidget_GrabMouse2(void* ptr, void* cursor)
{
		static_cast<QWidget*>(ptr)->grabMouse(*static_cast<QCursor*>(cursor));
}

int QWidget_GrabShortcut(void* ptr, void* key, long long context)
{
		return static_cast<QWidget*>(ptr)->grabShortcut(*static_cast<QKeySequence*>(key), static_cast<Qt::ShortcutContext>(context));
}

void* QWidget_GraphicsEffect(void* ptr)
{
		return static_cast<QWidget*>(ptr)->graphicsEffect();
}

void* QWidget_GraphicsProxyWidget(void* ptr)
{
		return static_cast<QWidget*>(ptr)->graphicsProxyWidget();
}

char QWidget_HasEditFocus(void* ptr)
{
#ifdef QT_KEYPAD_NAVIGATION
		return static_cast<QWidget*>(ptr)->hasEditFocus();
#else
	return false;
#endif
}

char QWidget_HasFocus(void* ptr)
{
		return static_cast<QWidget*>(ptr)->hasFocus();
}

char QWidget_HasHeightForWidth(void* ptr)
{
		return static_cast<QWidget*>(ptr)->hasHeightForWidth();
}

char QWidget_HasHeightForWidthDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizardPage*>(ptr)->QWizardPage::hasHeightForWidth();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBar*>(ptr)->QToolBar::hasHeightForWidth();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStatusBar*>(ptr)->QStatusBar::hasHeightForWidth();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::hasHeightForWidth();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplashScreen*>(ptr)->QSplashScreen::hasHeightForWidth();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSizeGrip*>(ptr)->QSizeGrip::hasHeightForWidth();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::hasHeightForWidth();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenuBar*>(ptr)->QMenuBar::hasHeightForWidth();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenu*>(ptr)->QMenu::hasHeightForWidth();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::hasHeightForWidth();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMainWindow*>(ptr)->QMainWindow::hasHeightForWidth();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::hasHeightForWidth();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLineEdit*>(ptr)->QLineEdit::hasHeightForWidth();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGroupBox*>(ptr)->QGroupBox::hasHeightForWidth();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressBar*>(ptr)->QProgressBar::hasHeightForWidth();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFocusFrame*>(ptr)->QFocusFrame::hasHeightForWidth();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDockWidget*>(ptr)->QDockWidget::hasHeightForWidth();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::hasHeightForWidth();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::hasHeightForWidth();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontComboBox*>(ptr)->QFontComboBox::hasHeightForWidth();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QComboBox*>(ptr)->QComboBox::hasHeightForWidth();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizard*>(ptr)->QWizard::hasHeightForWidth();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMessageBox*>(ptr)->QMessageBox::hasHeightForWidth();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QInputDialog*>(ptr)->QInputDialog::hasHeightForWidth();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressDialog*>(ptr)->QProgressDialog::hasHeightForWidth();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontDialog*>(ptr)->QFontDialog::hasHeightForWidth();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFileDialog*>(ptr)->QFileDialog::hasHeightForWidth();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QErrorMessage*>(ptr)->QErrorMessage::hasHeightForWidth();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColorDialog*>(ptr)->QColorDialog::hasHeightForWidth();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialog*>(ptr)->QDialog::hasHeightForWidth();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::hasHeightForWidth();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBox*>(ptr)->QToolBox::hasHeightForWidth();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedWidget*>(ptr)->QStackedWidget::hasHeightForWidth();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitter*>(ptr)->QSplitter::hasHeightForWidth();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLCDNumber*>(ptr)->QLCDNumber::hasHeightForWidth();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLabel*>(ptr)->QLabel::hasHeightForWidth();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::hasHeightForWidth();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextBrowser*>(ptr)->QTextBrowser::hasHeightForWidth();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextEdit*>(ptr)->QTextEdit::hasHeightForWidth();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiArea*>(ptr)->QMdiArea::hasHeightForWidth();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsView*>(ptr)->QGraphicsView::hasHeightForWidth();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollArea*>(ptr)->QScrollArea::hasHeightForWidth();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::hasHeightForWidth();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeView*>(ptr)->QTreeView::hasHeightForWidth();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::hasHeightForWidth();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableView*>(ptr)->QTableView::hasHeightForWidth();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::hasHeightForWidth();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::hasHeightForWidth();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListView*>(ptr)->QListView::hasHeightForWidth();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHeaderView*>(ptr)->QHeaderView::hasHeightForWidth();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColumnView*>(ptr)->QColumnView::hasHeightForWidth();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::hasHeightForWidth();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::hasHeightForWidth();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFrame*>(ptr)->QFrame::hasHeightForWidth();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRubberBand*>(ptr)->QRubberBand::hasHeightForWidth();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabBar*>(ptr)->QTabBar::hasHeightForWidth();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollBar*>(ptr)->QScrollBar::hasHeightForWidth();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDial*>(ptr)->QDial::hasHeightForWidth();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSlider*>(ptr)->QSlider::hasHeightForWidth();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::hasHeightForWidth();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::hasHeightForWidth();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSpinBox*>(ptr)->QSpinBox::hasHeightForWidth();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateEdit*>(ptr)->QDateEdit::hasHeightForWidth();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTimeEdit*>(ptr)->QTimeEdit::hasHeightForWidth();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::hasHeightForWidth();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::hasHeightForWidth();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabWidget*>(ptr)->QTabWidget::hasHeightForWidth();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolButton*>(ptr)->QToolButton::hasHeightForWidth();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioButton*>(ptr)->QRadioButton::hasHeightForWidth();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::hasHeightForWidth();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPushButton*>(ptr)->QPushButton::hasHeightForWidth();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCheckBox*>(ptr)->QCheckBox::hasHeightForWidth();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractButton*>(ptr)->QAbstractButton::hasHeightForWidth();
	} else {
		return static_cast<QWidget*>(ptr)->QWidget::hasHeightForWidth();
	}
}

char QWidget_HasMouseTracking(void* ptr)
{
		return static_cast<QWidget*>(ptr)->hasMouseTracking();
}

char QWidget_HasTabletTracking(void* ptr)
{
		return static_cast<QWidget*>(ptr)->hasTabletTracking();
}

int QWidget_Height(void* ptr)
{
		return static_cast<QWidget*>(ptr)->height();
}

int QWidget_HeightForWidth(void* ptr, int w)
{
		return static_cast<QWidget*>(ptr)->heightForWidth(w);
}

int QWidget_HeightForWidthDefault(void* ptr, int w)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizardPage*>(ptr)->QWizardPage::heightForWidth(w);
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBar*>(ptr)->QToolBar::heightForWidth(w);
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStatusBar*>(ptr)->QStatusBar::heightForWidth(w);
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::heightForWidth(w);
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplashScreen*>(ptr)->QSplashScreen::heightForWidth(w);
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSizeGrip*>(ptr)->QSizeGrip::heightForWidth(w);
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::heightForWidth(w);
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenuBar*>(ptr)->QMenuBar::heightForWidth(w);
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenu*>(ptr)->QMenu::heightForWidth(w);
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::heightForWidth(w);
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMainWindow*>(ptr)->QMainWindow::heightForWidth(w);
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::heightForWidth(w);
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLineEdit*>(ptr)->QLineEdit::heightForWidth(w);
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGroupBox*>(ptr)->QGroupBox::heightForWidth(w);
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressBar*>(ptr)->QProgressBar::heightForWidth(w);
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFocusFrame*>(ptr)->QFocusFrame::heightForWidth(w);
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDockWidget*>(ptr)->QDockWidget::heightForWidth(w);
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::heightForWidth(w);
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::heightForWidth(w);
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontComboBox*>(ptr)->QFontComboBox::heightForWidth(w);
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QComboBox*>(ptr)->QComboBox::heightForWidth(w);
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizard*>(ptr)->QWizard::heightForWidth(w);
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMessageBox*>(ptr)->QMessageBox::heightForWidth(w);
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QInputDialog*>(ptr)->QInputDialog::heightForWidth(w);
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressDialog*>(ptr)->QProgressDialog::heightForWidth(w);
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontDialog*>(ptr)->QFontDialog::heightForWidth(w);
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFileDialog*>(ptr)->QFileDialog::heightForWidth(w);
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QErrorMessage*>(ptr)->QErrorMessage::heightForWidth(w);
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColorDialog*>(ptr)->QColorDialog::heightForWidth(w);
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialog*>(ptr)->QDialog::heightForWidth(w);
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::heightForWidth(w);
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBox*>(ptr)->QToolBox::heightForWidth(w);
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedWidget*>(ptr)->QStackedWidget::heightForWidth(w);
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitter*>(ptr)->QSplitter::heightForWidth(w);
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLCDNumber*>(ptr)->QLCDNumber::heightForWidth(w);
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLabel*>(ptr)->QLabel::heightForWidth(w);
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::heightForWidth(w);
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextBrowser*>(ptr)->QTextBrowser::heightForWidth(w);
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextEdit*>(ptr)->QTextEdit::heightForWidth(w);
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiArea*>(ptr)->QMdiArea::heightForWidth(w);
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsView*>(ptr)->QGraphicsView::heightForWidth(w);
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollArea*>(ptr)->QScrollArea::heightForWidth(w);
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::heightForWidth(w);
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeView*>(ptr)->QTreeView::heightForWidth(w);
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::heightForWidth(w);
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableView*>(ptr)->QTableView::heightForWidth(w);
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::heightForWidth(w);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::heightForWidth(w);
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListView*>(ptr)->QListView::heightForWidth(w);
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHeaderView*>(ptr)->QHeaderView::heightForWidth(w);
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColumnView*>(ptr)->QColumnView::heightForWidth(w);
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::heightForWidth(w);
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::heightForWidth(w);
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFrame*>(ptr)->QFrame::heightForWidth(w);
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRubberBand*>(ptr)->QRubberBand::heightForWidth(w);
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabBar*>(ptr)->QTabBar::heightForWidth(w);
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollBar*>(ptr)->QScrollBar::heightForWidth(w);
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDial*>(ptr)->QDial::heightForWidth(w);
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSlider*>(ptr)->QSlider::heightForWidth(w);
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::heightForWidth(w);
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::heightForWidth(w);
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSpinBox*>(ptr)->QSpinBox::heightForWidth(w);
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateEdit*>(ptr)->QDateEdit::heightForWidth(w);
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTimeEdit*>(ptr)->QTimeEdit::heightForWidth(w);
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::heightForWidth(w);
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::heightForWidth(w);
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabWidget*>(ptr)->QTabWidget::heightForWidth(w);
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolButton*>(ptr)->QToolButton::heightForWidth(w);
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioButton*>(ptr)->QRadioButton::heightForWidth(w);
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::heightForWidth(w);
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPushButton*>(ptr)->QPushButton::heightForWidth(w);
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCheckBox*>(ptr)->QCheckBox::heightForWidth(w);
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractButton*>(ptr)->QAbstractButton::heightForWidth(w);
	} else {
		return static_cast<QWidget*>(ptr)->QWidget::heightForWidth(w);
	}
}

void QWidget_Hide(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "hide");
}

void QWidget_HideDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::hide();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::hide();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::hide();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::hide();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::hide();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::hide();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::hide();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::hide();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::hide();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::hide();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::hide();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::hide();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::hide();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::hide();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::hide();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::hide();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::hide();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::hide();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::hide();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::hide();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::hide();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::hide();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::hide();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::hide();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::hide();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::hide();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::hide();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::hide();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::hide();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::hide();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::hide();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::hide();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::hide();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::hide();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::hide();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::hide();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::hide();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::hide();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::hide();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::hide();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::hide();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::hide();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::hide();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::hide();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::hide();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::hide();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::hide();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::hide();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::hide();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::hide();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::hide();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::hide();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::hide();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::hide();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::hide();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::hide();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::hide();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::hide();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::hide();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::hide();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::hide();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::hide();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::hide();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::hide();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::hide();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::hide();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::hide();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::hide();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::hide();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::hide();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::hide();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::hide();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::hide();
	} else {
		static_cast<QWidget*>(ptr)->QWidget::hide();
	}
}

void QWidget_HideEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QWidget_HideEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::hideEvent(static_cast<QHideEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::hideEvent(static_cast<QHideEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::hideEvent(static_cast<QHideEvent*>(event));
	}
}

void QWidget_InitPainter(void* ptr, void* painter)
{
		static_cast<QWidget*>(ptr)->initPainter(static_cast<QPainter*>(painter));
}

void QWidget_InitPainterDefault(void* ptr, void* painter)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::initPainter(static_cast<QPainter*>(painter));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::initPainter(static_cast<QPainter*>(painter));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::initPainter(static_cast<QPainter*>(painter));
	}
}

void QWidget_InputMethodEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QWidget_InputMethodEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
	}
}

long long QWidget_InputMethodHints(void* ptr)
{
		return static_cast<QWidget*>(ptr)->inputMethodHints();
}

void* QWidget_InputMethodQuery(void* ptr, long long query)
{
		return new QVariant(static_cast<QWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QWidget_InputMethodQueryDefault(void* ptr, long long query)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QWizardPage*>(ptr)->QWizardPage::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QToolBar*>(ptr)->QToolBar::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QStatusBar*>(ptr)->QStatusBar::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QSplashScreen*>(ptr)->QSplashScreen::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QSizeGrip*>(ptr)->QSizeGrip::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QMenuBar*>(ptr)->QMenuBar::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QMenu*>(ptr)->QMenu::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QMainWindow*>(ptr)->QMainWindow::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QLineEdit*>(ptr)->QLineEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGroupBox*>(ptr)->QGroupBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QProgressBar*>(ptr)->QProgressBar::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QFocusFrame*>(ptr)->QFocusFrame::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QDockWidget*>(ptr)->QDockWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QFontComboBox*>(ptr)->QFontComboBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QComboBox*>(ptr)->QComboBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QWizard*>(ptr)->QWizard::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QMessageBox*>(ptr)->QMessageBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QInputDialog*>(ptr)->QInputDialog::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QProgressDialog*>(ptr)->QProgressDialog::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QFontDialog*>(ptr)->QFontDialog::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QFileDialog*>(ptr)->QFileDialog::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QErrorMessage*>(ptr)->QErrorMessage::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QColorDialog*>(ptr)->QColorDialog::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QDialog*>(ptr)->QDialog::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QToolBox*>(ptr)->QToolBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QStackedWidget*>(ptr)->QStackedWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QSplitter*>(ptr)->QSplitter::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QLCDNumber*>(ptr)->QLCDNumber::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QLabel*>(ptr)->QLabel::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QTextBrowser*>(ptr)->QTextBrowser::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QTextEdit*>(ptr)->QTextEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QMdiArea*>(ptr)->QMdiArea::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QGraphicsView*>(ptr)->QGraphicsView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QScrollArea*>(ptr)->QScrollArea::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QTreeWidget*>(ptr)->QTreeWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QTreeView*>(ptr)->QTreeView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QTableWidget*>(ptr)->QTableWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QTableView*>(ptr)->QTableView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QUndoView*>(ptr)->QUndoView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QListWidget*>(ptr)->QListWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QListView*>(ptr)->QListView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QHeaderView*>(ptr)->QHeaderView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QColumnView*>(ptr)->QColumnView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QFrame*>(ptr)->QFrame::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QRubberBand*>(ptr)->QRubberBand::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QTabBar*>(ptr)->QTabBar::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QScrollBar*>(ptr)->QScrollBar::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QDial*>(ptr)->QDial::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QSlider*>(ptr)->QSlider::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QSpinBox*>(ptr)->QSpinBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QDateEdit*>(ptr)->QDateEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QTimeEdit*>(ptr)->QTimeEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QTabWidget*>(ptr)->QTabWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QToolButton*>(ptr)->QToolButton::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QRadioButton*>(ptr)->QRadioButton::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QPushButton*>(ptr)->QPushButton::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QCheckBox*>(ptr)->QCheckBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		return new QVariant(static_cast<QAbstractButton*>(ptr)->QAbstractButton::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	} else {
		return new QVariant(static_cast<QWidget*>(ptr)->QWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
	}
}

void QWidget_InsertAction(void* ptr, void* before, void* action)
{
		static_cast<QWidget*>(ptr)->insertAction(static_cast<QAction*>(before), static_cast<QAction*>(action));
}

void QWidget_InsertActions(void* ptr, void* before, void* actions)
{
		static_cast<QWidget*>(ptr)->insertActions(static_cast<QAction*>(before), ({ QList<QAction *>* tmpP = static_cast<QList<QAction *>*>(actions); QList<QAction *> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
}

char QWidget_IsActiveWindow(void* ptr)
{
		return static_cast<QWidget*>(ptr)->isActiveWindow();
}

char QWidget_IsAncestorOf(void* ptr, void* child)
{
		return static_cast<QWidget*>(ptr)->isAncestorOf(static_cast<QWidget*>(child));
}

char QWidget_IsEnabled(void* ptr)
{
		return static_cast<QWidget*>(ptr)->isEnabled();
}

char QWidget_IsEnabledTo(void* ptr, void* ancestor)
{
		return static_cast<QWidget*>(ptr)->isEnabledTo(static_cast<QWidget*>(ancestor));
}

char QWidget_IsFullScreen(void* ptr)
{
		return static_cast<QWidget*>(ptr)->isFullScreen();
}

char QWidget_IsHidden(void* ptr)
{
		return static_cast<QWidget*>(ptr)->isHidden();
}

char QWidget_IsMaximized(void* ptr)
{
		return static_cast<QWidget*>(ptr)->isMaximized();
}

char QWidget_IsMinimized(void* ptr)
{
		return static_cast<QWidget*>(ptr)->isMinimized();
}

char QWidget_IsModal(void* ptr)
{
		return static_cast<QWidget*>(ptr)->isModal();
}

char QWidget_IsVisible(void* ptr)
{
		return static_cast<QWidget*>(ptr)->isVisible();
}

char QWidget_IsVisibleTo(void* ptr, void* ancestor)
{
		return static_cast<QWidget*>(ptr)->isVisibleTo(static_cast<QWidget*>(ancestor));
}

char QWidget_IsWindow(void* ptr)
{
		return static_cast<QWidget*>(ptr)->isWindow();
}

char QWidget_IsWindowModified(void* ptr)
{
		return static_cast<QWidget*>(ptr)->isWindowModified();
}

void QWidget_KeyPressEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QWidget_KeyPressEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::keyPressEvent(static_cast<QKeyEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
	}
}

void QWidget_KeyReleaseEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QWidget_KeyReleaseEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
	}
}

void* QWidget_QWidget_KeyboardGrabber()
{
		return QWidget::keyboardGrabber();
}

void* QWidget_Layout(void* ptr)
{
		return static_cast<QWidget*>(ptr)->layout();
}

long long QWidget_LayoutDirection(void* ptr)
{
		return static_cast<QWidget*>(ptr)->layoutDirection();
}

void QWidget_LeaveEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QWidget_LeaveEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::leaveEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::leaveEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::leaveEvent(static_cast<QEvent*>(event));
	}
}

void* QWidget_Locale(void* ptr)
{
		return new QLocale(static_cast<QWidget*>(ptr)->locale());
}

void QWidget_Lower(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "lower");
}

void QWidget_LowerDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::lower();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::lower();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::lower();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::lower();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::lower();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::lower();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::lower();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::lower();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::lower();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::lower();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::lower();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::lower();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::lower();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::lower();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::lower();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::lower();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::lower();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::lower();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::lower();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::lower();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::lower();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::lower();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::lower();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::lower();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::lower();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::lower();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::lower();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::lower();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::lower();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::lower();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::lower();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::lower();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::lower();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::lower();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::lower();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::lower();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::lower();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::lower();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::lower();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::lower();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::lower();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::lower();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::lower();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::lower();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::lower();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::lower();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::lower();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::lower();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::lower();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::lower();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::lower();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::lower();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::lower();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::lower();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::lower();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::lower();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::lower();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::lower();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::lower();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::lower();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::lower();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::lower();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::lower();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::lower();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::lower();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::lower();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::lower();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::lower();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::lower();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::lower();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::lower();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::lower();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::lower();
	} else {
		static_cast<QWidget*>(ptr)->QWidget::lower();
	}
}

void* QWidget_MapFrom(void* ptr, void* parent, void* pos)
{
		return ({ QPoint tmpValue = static_cast<QWidget*>(ptr)->mapFrom(static_cast<QWidget*>(parent), *static_cast<QPoint*>(pos)); new QPoint(tmpValue.x(), tmpValue.y()); });
}

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

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

void* QWidget_MapTo(void* ptr, void* parent, void* pos)
{
		return ({ QPoint tmpValue = static_cast<QWidget*>(ptr)->mapTo(static_cast<QWidget*>(parent), *static_cast<QPoint*>(pos)); new QPoint(tmpValue.x(), tmpValue.y()); });
}

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

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

void* QWidget_Mask(void* ptr)
{
		return new QRegion(static_cast<QWidget*>(ptr)->mask());
}

int QWidget_MaximumHeight(void* ptr)
{
		return static_cast<QWidget*>(ptr)->maximumHeight();
}

void* QWidget_MaximumSize(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QWidget_MaximumWidth(void* ptr)
{
		return static_cast<QWidget*>(ptr)->maximumWidth();
}

int QWidget_Metric(void* ptr, long long m)
{
		return static_cast<QWidget*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
}

int QWidget_MetricDefault(void* ptr, long long m)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizardPage*>(ptr)->QWizardPage::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBar*>(ptr)->QToolBar::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStatusBar*>(ptr)->QStatusBar::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplashScreen*>(ptr)->QSplashScreen::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSizeGrip*>(ptr)->QSizeGrip::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenuBar*>(ptr)->QMenuBar::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenu*>(ptr)->QMenu::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMainWindow*>(ptr)->QMainWindow::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLineEdit*>(ptr)->QLineEdit::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGroupBox*>(ptr)->QGroupBox::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressBar*>(ptr)->QProgressBar::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFocusFrame*>(ptr)->QFocusFrame::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDockWidget*>(ptr)->QDockWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontComboBox*>(ptr)->QFontComboBox::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QComboBox*>(ptr)->QComboBox::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizard*>(ptr)->QWizard::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMessageBox*>(ptr)->QMessageBox::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QInputDialog*>(ptr)->QInputDialog::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressDialog*>(ptr)->QProgressDialog::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontDialog*>(ptr)->QFontDialog::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFileDialog*>(ptr)->QFileDialog::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QErrorMessage*>(ptr)->QErrorMessage::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColorDialog*>(ptr)->QColorDialog::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialog*>(ptr)->QDialog::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBox*>(ptr)->QToolBox::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedWidget*>(ptr)->QStackedWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitter*>(ptr)->QSplitter::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLCDNumber*>(ptr)->QLCDNumber::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLabel*>(ptr)->QLabel::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextBrowser*>(ptr)->QTextBrowser::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextEdit*>(ptr)->QTextEdit::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiArea*>(ptr)->QMdiArea::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsView*>(ptr)->QGraphicsView::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollArea*>(ptr)->QScrollArea::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeView*>(ptr)->QTreeView::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableView*>(ptr)->QTableView::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListView*>(ptr)->QListView::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHeaderView*>(ptr)->QHeaderView::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColumnView*>(ptr)->QColumnView::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFrame*>(ptr)->QFrame::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRubberBand*>(ptr)->QRubberBand::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabBar*>(ptr)->QTabBar::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollBar*>(ptr)->QScrollBar::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDial*>(ptr)->QDial::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSlider*>(ptr)->QSlider::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSpinBox*>(ptr)->QSpinBox::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateEdit*>(ptr)->QDateEdit::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTimeEdit*>(ptr)->QTimeEdit::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabWidget*>(ptr)->QTabWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolButton*>(ptr)->QToolButton::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioButton*>(ptr)->QRadioButton::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPushButton*>(ptr)->QPushButton::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCheckBox*>(ptr)->QCheckBox::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractButton*>(ptr)->QAbstractButton::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	} else {
		return static_cast<QWidget*>(ptr)->QWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
	}
}

int QWidget_MinimumHeight(void* ptr)
{
		return static_cast<QWidget*>(ptr)->minimumHeight();
}

void* QWidget_MinimumSize(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWidget_MinimumSizeHint(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWidget_MinimumSizeHintDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QWizardPage*>(ptr)->QWizardPage::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QToolBar*>(ptr)->QToolBar::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QStatusBar*>(ptr)->QStatusBar::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QSplashScreen*>(ptr)->QSplashScreen::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QSizeGrip*>(ptr)->QSizeGrip::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QMenuBar*>(ptr)->QMenuBar::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QMenu*>(ptr)->QMenu::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QMainWindow*>(ptr)->QMainWindow::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QLineEdit*>(ptr)->QLineEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QGroupBox*>(ptr)->QGroupBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QProgressBar*>(ptr)->QProgressBar::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QFocusFrame*>(ptr)->QFocusFrame::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDockWidget*>(ptr)->QDockWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QFontComboBox*>(ptr)->QFontComboBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QComboBox*>(ptr)->QComboBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QWizard*>(ptr)->QWizard::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QMessageBox*>(ptr)->QMessageBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QInputDialog*>(ptr)->QInputDialog::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QProgressDialog*>(ptr)->QProgressDialog::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QFontDialog*>(ptr)->QFontDialog::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QFileDialog*>(ptr)->QFileDialog::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QErrorMessage*>(ptr)->QErrorMessage::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QColorDialog*>(ptr)->QColorDialog::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDialog*>(ptr)->QDialog::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QToolBox*>(ptr)->QToolBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QStackedWidget*>(ptr)->QStackedWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QSplitter*>(ptr)->QSplitter::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QLCDNumber*>(ptr)->QLCDNumber::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QLabel*>(ptr)->QLabel::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTextBrowser*>(ptr)->QTextBrowser::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTextEdit*>(ptr)->QTextEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QMdiArea*>(ptr)->QMdiArea::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QGraphicsView*>(ptr)->QGraphicsView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QScrollArea*>(ptr)->QScrollArea::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTreeWidget*>(ptr)->QTreeWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTreeView*>(ptr)->QTreeView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTableWidget*>(ptr)->QTableWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTableView*>(ptr)->QTableView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QUndoView*>(ptr)->QUndoView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QListWidget*>(ptr)->QListWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QListView*>(ptr)->QListView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QHeaderView*>(ptr)->QHeaderView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QColumnView*>(ptr)->QColumnView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QFrame*>(ptr)->QFrame::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QRubberBand*>(ptr)->QRubberBand::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTabBar*>(ptr)->QTabBar::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QScrollBar*>(ptr)->QScrollBar::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDial*>(ptr)->QDial::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QSlider*>(ptr)->QSlider::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QSpinBox*>(ptr)->QSpinBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDateEdit*>(ptr)->QDateEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTimeEdit*>(ptr)->QTimeEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTabWidget*>(ptr)->QTabWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QToolButton*>(ptr)->QToolButton::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QRadioButton*>(ptr)->QRadioButton::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QPushButton*>(ptr)->QPushButton::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QCheckBox*>(ptr)->QCheckBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QAbstractButton*>(ptr)->QAbstractButton::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->QWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

int QWidget_MinimumWidth(void* ptr)
{
		return static_cast<QWidget*>(ptr)->minimumWidth();
}

void QWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
	}
}

void* QWidget_QWidget_MouseGrabber()
{
		return QWidget::mouseGrabber();
}

void QWidget_MouseMoveEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QWidget_MouseMoveEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
	}
}

void QWidget_MousePressEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QWidget_MousePressEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::mousePressEvent(static_cast<QMouseEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
	}
}

void QWidget_MouseReleaseEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QWidget_MouseReleaseEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
	}
}

void QWidget_Move(void* ptr, void* vqp)
{
		static_cast<QWidget*>(ptr)->move(*static_cast<QPoint*>(vqp));
}

void QWidget_Move2(void* ptr, int x, int y)
{
		static_cast<QWidget*>(ptr)->move(x, y);
}

void QWidget_MoveEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QWidget_MoveEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::moveEvent(static_cast<QMoveEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::moveEvent(static_cast<QMoveEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::moveEvent(static_cast<QMoveEvent*>(event));
	}
}

char QWidget_NativeEvent(void* ptr, void* eventType, void* message, long* result)
{
		return static_cast<QWidget*>(ptr)->nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
}

char QWidget_NativeEventDefault(void* ptr, void* eventType, void* message, long* result)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizardPage*>(ptr)->QWizardPage::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBar*>(ptr)->QToolBar::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStatusBar*>(ptr)->QStatusBar::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplashScreen*>(ptr)->QSplashScreen::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSizeGrip*>(ptr)->QSizeGrip::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenuBar*>(ptr)->QMenuBar::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenu*>(ptr)->QMenu::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMainWindow*>(ptr)->QMainWindow::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLineEdit*>(ptr)->QLineEdit::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGroupBox*>(ptr)->QGroupBox::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressBar*>(ptr)->QProgressBar::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFocusFrame*>(ptr)->QFocusFrame::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDockWidget*>(ptr)->QDockWidget::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontComboBox*>(ptr)->QFontComboBox::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QComboBox*>(ptr)->QComboBox::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizard*>(ptr)->QWizard::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMessageBox*>(ptr)->QMessageBox::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QInputDialog*>(ptr)->QInputDialog::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressDialog*>(ptr)->QProgressDialog::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontDialog*>(ptr)->QFontDialog::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFileDialog*>(ptr)->QFileDialog::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QErrorMessage*>(ptr)->QErrorMessage::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColorDialog*>(ptr)->QColorDialog::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialog*>(ptr)->QDialog::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBox*>(ptr)->QToolBox::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedWidget*>(ptr)->QStackedWidget::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitter*>(ptr)->QSplitter::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLCDNumber*>(ptr)->QLCDNumber::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLabel*>(ptr)->QLabel::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextBrowser*>(ptr)->QTextBrowser::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextEdit*>(ptr)->QTextEdit::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiArea*>(ptr)->QMdiArea::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsView*>(ptr)->QGraphicsView::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollArea*>(ptr)->QScrollArea::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeView*>(ptr)->QTreeView::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableView*>(ptr)->QTableView::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListView*>(ptr)->QListView::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHeaderView*>(ptr)->QHeaderView::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColumnView*>(ptr)->QColumnView::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFrame*>(ptr)->QFrame::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRubberBand*>(ptr)->QRubberBand::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabBar*>(ptr)->QTabBar::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollBar*>(ptr)->QScrollBar::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDial*>(ptr)->QDial::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSlider*>(ptr)->QSlider::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSpinBox*>(ptr)->QSpinBox::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateEdit*>(ptr)->QDateEdit::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTimeEdit*>(ptr)->QTimeEdit::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabWidget*>(ptr)->QTabWidget::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolButton*>(ptr)->QToolButton::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioButton*>(ptr)->QRadioButton::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPushButton*>(ptr)->QPushButton::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCheckBox*>(ptr)->QCheckBox::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractButton*>(ptr)->QAbstractButton::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	} else {
		return static_cast<QWidget*>(ptr)->QWidget::nativeEvent(*static_cast<QByteArray*>(eventType), message, result);
	}
}

void* QWidget_NativeParentWidget(void* ptr)
{
		return static_cast<QWidget*>(ptr)->nativeParentWidget();
}

void* QWidget_NextInFocusChain(void* ptr)
{
		return static_cast<QWidget*>(ptr)->nextInFocusChain();
}

void* QWidget_NormalGeometry(void* ptr)
{
		return ({ QRect tmpValue = static_cast<QWidget*>(ptr)->normalGeometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QWidget_OverrideWindowFlags(void* ptr, long long flags)
{
		static_cast<QWidget*>(ptr)->overrideWindowFlags(static_cast<Qt::WindowType>(flags));
}

void* QWidget_PaintEngine(void* ptr)
{
		return static_cast<QWidget*>(ptr)->paintEngine();
}

void* QWidget_PaintEngineDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizardPage*>(ptr)->QWizardPage::paintEngine();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBar*>(ptr)->QToolBar::paintEngine();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStatusBar*>(ptr)->QStatusBar::paintEngine();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::paintEngine();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplashScreen*>(ptr)->QSplashScreen::paintEngine();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSizeGrip*>(ptr)->QSizeGrip::paintEngine();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::paintEngine();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenuBar*>(ptr)->QMenuBar::paintEngine();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMenu*>(ptr)->QMenu::paintEngine();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::paintEngine();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMainWindow*>(ptr)->QMainWindow::paintEngine();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::paintEngine();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLineEdit*>(ptr)->QLineEdit::paintEngine();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGroupBox*>(ptr)->QGroupBox::paintEngine();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressBar*>(ptr)->QProgressBar::paintEngine();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFocusFrame*>(ptr)->QFocusFrame::paintEngine();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDockWidget*>(ptr)->QDockWidget::paintEngine();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::paintEngine();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::paintEngine();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontComboBox*>(ptr)->QFontComboBox::paintEngine();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QComboBox*>(ptr)->QComboBox::paintEngine();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWizard*>(ptr)->QWizard::paintEngine();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMessageBox*>(ptr)->QMessageBox::paintEngine();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QInputDialog*>(ptr)->QInputDialog::paintEngine();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QProgressDialog*>(ptr)->QProgressDialog::paintEngine();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFontDialog*>(ptr)->QFontDialog::paintEngine();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFileDialog*>(ptr)->QFileDialog::paintEngine();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QErrorMessage*>(ptr)->QErrorMessage::paintEngine();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColorDialog*>(ptr)->QColorDialog::paintEngine();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDialog*>(ptr)->QDialog::paintEngine();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::paintEngine();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolBox*>(ptr)->QToolBox::paintEngine();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QStackedWidget*>(ptr)->QStackedWidget::paintEngine();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSplitter*>(ptr)->QSplitter::paintEngine();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLCDNumber*>(ptr)->QLCDNumber::paintEngine();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		return static_cast<QLabel*>(ptr)->QLabel::paintEngine();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::paintEngine();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextBrowser*>(ptr)->QTextBrowser::paintEngine();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextEdit*>(ptr)->QTextEdit::paintEngine();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QMdiArea*>(ptr)->QMdiArea::paintEngine();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QGraphicsView*>(ptr)->QGraphicsView::paintEngine();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollArea*>(ptr)->QScrollArea::paintEngine();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeWidget*>(ptr)->QTreeWidget::paintEngine();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTreeView*>(ptr)->QTreeView::paintEngine();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableWidget*>(ptr)->QTableWidget::paintEngine();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTableView*>(ptr)->QTableView::paintEngine();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QUndoView*>(ptr)->QUndoView::paintEngine();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListWidget*>(ptr)->QListWidget::paintEngine();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QListView*>(ptr)->QListView::paintEngine();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QHeaderView*>(ptr)->QHeaderView::paintEngine();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QColumnView*>(ptr)->QColumnView::paintEngine();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::paintEngine();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::paintEngine();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QFrame*>(ptr)->QFrame::paintEngine();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRubberBand*>(ptr)->QRubberBand::paintEngine();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabBar*>(ptr)->QTabBar::paintEngine();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		return static_cast<QScrollBar*>(ptr)->QScrollBar::paintEngine();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDial*>(ptr)->QDial::paintEngine();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSlider*>(ptr)->QSlider::paintEngine();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::paintEngine();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::paintEngine();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QSpinBox*>(ptr)->QSpinBox::paintEngine();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateEdit*>(ptr)->QDateEdit::paintEngine();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTimeEdit*>(ptr)->QTimeEdit::paintEngine();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::paintEngine();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::paintEngine();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTabWidget*>(ptr)->QTabWidget::paintEngine();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QToolButton*>(ptr)->QToolButton::paintEngine();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRadioButton*>(ptr)->QRadioButton::paintEngine();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::paintEngine();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPushButton*>(ptr)->QPushButton::paintEngine();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		return static_cast<QCheckBox*>(ptr)->QCheckBox::paintEngine();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAbstractButton*>(ptr)->QAbstractButton::paintEngine();
	} else {
		return static_cast<QWidget*>(ptr)->QWidget::paintEngine();
	}
}

void QWidget_PaintEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QWidget_PaintEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::paintEvent(static_cast<QPaintEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::paintEvent(static_cast<QPaintEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::paintEvent(static_cast<QPaintEvent*>(event));
	}
}

void* QWidget_Palette(void* ptr)
{
		return const_cast<QPalette*>(&static_cast<QWidget*>(ptr)->palette());
}

void* QWidget_ParentWidget(void* ptr)
{
		return static_cast<QWidget*>(ptr)->parentWidget();
}

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

void* QWidget_PreviousInFocusChain(void* ptr)
{
		return static_cast<QWidget*>(ptr)->previousInFocusChain();
}

void QWidget_Raise(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "raise");
}

void QWidget_RaiseDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::raise();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::raise();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::raise();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::raise();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::raise();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::raise();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::raise();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::raise();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::raise();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::raise();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::raise();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::raise();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::raise();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::raise();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::raise();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::raise();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::raise();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::raise();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::raise();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::raise();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::raise();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::raise();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::raise();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::raise();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::raise();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::raise();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::raise();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::raise();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::raise();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::raise();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::raise();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::raise();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::raise();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::raise();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::raise();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::raise();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::raise();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::raise();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::raise();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::raise();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::raise();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::raise();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::raise();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::raise();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::raise();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::raise();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::raise();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::raise();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::raise();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::raise();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::raise();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::raise();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::raise();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::raise();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::raise();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::raise();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::raise();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::raise();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::raise();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::raise();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::raise();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::raise();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::raise();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::raise();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::raise();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::raise();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::raise();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::raise();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::raise();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::raise();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::raise();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::raise();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::raise();
	} else {
		static_cast<QWidget*>(ptr)->QWidget::raise();
	}
}

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

void QWidget_ReleaseKeyboard(void* ptr)
{
		static_cast<QWidget*>(ptr)->releaseKeyboard();
}

void QWidget_ReleaseMouse(void* ptr)
{
		static_cast<QWidget*>(ptr)->releaseMouse();
}

void QWidget_ReleaseShortcut(void* ptr, int id)
{
		static_cast<QWidget*>(ptr)->releaseShortcut(id);
}

void QWidget_RemoveAction(void* ptr, void* action)
{
		static_cast<QWidget*>(ptr)->removeAction(static_cast<QAction*>(action));
}

void QWidget_Render(void* ptr, void* target, void* targetOffset, void* sourceRegion, long long renderFlags)
{
	if (dynamic_cast<QWidget*>(static_cast<QObject*>(target))) {
		static_cast<QWidget*>(ptr)->render(static_cast<QWidget*>(target), *static_cast<QPoint*>(targetOffset), *static_cast<QRegion*>(sourceRegion), static_cast<QWidget::RenderFlag>(renderFlags));
	} else {
		static_cast<QWidget*>(ptr)->render(static_cast<QPaintDevice*>(target), *static_cast<QPoint*>(targetOffset), *static_cast<QRegion*>(sourceRegion), static_cast<QWidget::RenderFlag>(renderFlags));
	}
}

void QWidget_Render2(void* ptr, void* painter, void* targetOffset, void* sourceRegion, long long renderFlags)
{
		static_cast<QWidget*>(ptr)->render(static_cast<QPainter*>(painter), *static_cast<QPoint*>(targetOffset), *static_cast<QRegion*>(sourceRegion), static_cast<QWidget::RenderFlag>(renderFlags));
}

void QWidget_Repaint(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "repaint");
}

void QWidget_RepaintDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::repaint();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::repaint();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::repaint();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::repaint();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::repaint();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::repaint();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::repaint();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::repaint();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::repaint();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::repaint();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::repaint();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::repaint();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::repaint();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::repaint();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::repaint();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::repaint();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::repaint();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::repaint();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::repaint();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::repaint();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::repaint();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::repaint();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::repaint();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::repaint();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::repaint();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::repaint();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::repaint();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::repaint();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::repaint();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::repaint();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::repaint();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::repaint();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::repaint();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::repaint();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::repaint();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::repaint();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::repaint();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::repaint();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::repaint();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::repaint();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::repaint();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::repaint();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::repaint();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::repaint();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::repaint();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::repaint();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::repaint();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::repaint();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::repaint();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::repaint();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::repaint();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::repaint();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::repaint();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::repaint();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::repaint();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::repaint();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::repaint();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::repaint();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::repaint();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::repaint();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::repaint();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::repaint();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::repaint();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::repaint();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::repaint();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::repaint();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::repaint();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::repaint();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::repaint();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::repaint();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::repaint();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::repaint();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::repaint();
	} else {
		static_cast<QWidget*>(ptr)->QWidget::repaint();
	}
}

void QWidget_Repaint2(void* ptr, int x, int y, int w, int h)
{
		static_cast<QWidget*>(ptr)->repaint(x, y, w, h);
}

void QWidget_Repaint3(void* ptr, void* rect)
{
		static_cast<QWidget*>(ptr)->repaint(*static_cast<QRect*>(rect));
}

void QWidget_Repaint4(void* ptr, void* rgn)
{
		static_cast<QWidget*>(ptr)->repaint(*static_cast<QRegion*>(rgn));
}

void QWidget_Resize(void* ptr, void* vqs)
{
		static_cast<QWidget*>(ptr)->resize(*static_cast<QSize*>(vqs));
}

void QWidget_Resize2(void* ptr, int w, int h)
{
		static_cast<QWidget*>(ptr)->resize(w, h);
}

void QWidget_ResizeEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QWidget_ResizeEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::resizeEvent(static_cast<QResizeEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::resizeEvent(static_cast<QResizeEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::resizeEvent(static_cast<QResizeEvent*>(event));
	}
}

char QWidget_RestoreGeometry(void* ptr, void* geometry)
{
		return static_cast<QWidget*>(ptr)->restoreGeometry(*static_cast<QByteArray*>(geometry));
}

void* QWidget_SaveGeometry(void* ptr)
{
		return new QByteArray(static_cast<QWidget*>(ptr)->saveGeometry());
}

void QWidget_Scroll(void* ptr, int dx, int dy)
{
		static_cast<QWidget*>(ptr)->scroll(dx, dy);
}

void QWidget_Scroll2(void* ptr, int dx, int dy, void* r)
{
		static_cast<QWidget*>(ptr)->scroll(dx, dy, *static_cast<QRect*>(r));
}

void QWidget_SetAcceptDrops(void* ptr, char on)
{
		static_cast<QWidget*>(ptr)->setAcceptDrops(on != 0);
}

void QWidget_SetAccessibleDescription(void* ptr, struct QtWidgets_PackedString description)
{
		static_cast<QWidget*>(ptr)->setAccessibleDescription(QString::fromUtf8(description.data, description.len));
}

void QWidget_SetAccessibleName(void* ptr, struct QtWidgets_PackedString name)
{
		static_cast<QWidget*>(ptr)->setAccessibleName(QString::fromUtf8(name.data, name.len));
}

void QWidget_SetAttribute(void* ptr, long long attribute, char on)
{
		static_cast<QWidget*>(ptr)->setAttribute(static_cast<Qt::WidgetAttribute>(attribute), on != 0);
}

void QWidget_SetAutoFillBackground(void* ptr, char enabled)
{
		static_cast<QWidget*>(ptr)->setAutoFillBackground(enabled != 0);
}

void QWidget_SetBackgroundRole(void* ptr, long long role)
{
		static_cast<QWidget*>(ptr)->setBackgroundRole(static_cast<QPalette::ColorRole>(role));
}

void QWidget_SetBaseSize(void* ptr, void* vqs)
{
		static_cast<QWidget*>(ptr)->setBaseSize(*static_cast<QSize*>(vqs));
}

void QWidget_SetBaseSize2(void* ptr, int basew, int baseh)
{
		static_cast<QWidget*>(ptr)->setBaseSize(basew, baseh);
}

void QWidget_SetContentsMargins(void* ptr, int left, int top, int right, int bottom)
{
		static_cast<QWidget*>(ptr)->setContentsMargins(left, top, right, bottom);
}

void QWidget_SetContentsMargins2(void* ptr, void* margins)
{
		static_cast<QWidget*>(ptr)->setContentsMargins(*static_cast<QMargins*>(margins));
}

void QWidget_SetContextMenuPolicy(void* ptr, long long policy)
{
		static_cast<QWidget*>(ptr)->setContextMenuPolicy(static_cast<Qt::ContextMenuPolicy>(policy));
}

void QWidget_SetCursor(void* ptr, void* vqc)
{
		static_cast<QWidget*>(ptr)->setCursor(*static_cast<QCursor*>(vqc));
}

void QWidget_SetDisabled(void* ptr, char disable)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QWidget_SetDisabledDefault(void* ptr, char disable)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::setDisabled(disable != 0);
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::setDisabled(disable != 0);
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::setDisabled(disable != 0);
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setDisabled(disable != 0);
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::setDisabled(disable != 0);
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::setDisabled(disable != 0);
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::setDisabled(disable != 0);
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::setDisabled(disable != 0);
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::setDisabled(disable != 0);
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setDisabled(disable != 0);
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::setDisabled(disable != 0);
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setDisabled(disable != 0);
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::setDisabled(disable != 0);
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::setDisabled(disable != 0);
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::setDisabled(disable != 0);
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::setDisabled(disable != 0);
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::setDisabled(disable != 0);
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setDisabled(disable != 0);
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setDisabled(disable != 0);
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setDisabled(disable != 0);
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::setDisabled(disable != 0);
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::setDisabled(disable != 0);
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::setDisabled(disable != 0);
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::setDisabled(disable != 0);
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setDisabled(disable != 0);
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::setDisabled(disable != 0);
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::setDisabled(disable != 0);
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::setDisabled(disable != 0);
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::setDisabled(disable != 0);
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::setDisabled(disable != 0);
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setDisabled(disable != 0);
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::setDisabled(disable != 0);
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::setDisabled(disable != 0);
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::setDisabled(disable != 0);
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::setDisabled(disable != 0);
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::setDisabled(disable != 0);
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setDisabled(disable != 0);
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setDisabled(disable != 0);
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setDisabled(disable != 0);
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::setDisabled(disable != 0);
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::setDisabled(disable != 0);
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::setDisabled(disable != 0);
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setDisabled(disable != 0);
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::setDisabled(disable != 0);
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setDisabled(disable != 0);
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::setDisabled(disable != 0);
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setDisabled(disable != 0);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setDisabled(disable != 0);
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::setDisabled(disable != 0);
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::setDisabled(disable != 0);
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::setDisabled(disable != 0);
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setDisabled(disable != 0);
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setDisabled(disable != 0);
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::setDisabled(disable != 0);
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::setDisabled(disable != 0);
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::setDisabled(disable != 0);
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::setDisabled(disable != 0);
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::setDisabled(disable != 0);
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::setDisabled(disable != 0);
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setDisabled(disable != 0);
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setDisabled(disable != 0);
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::setDisabled(disable != 0);
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::setDisabled(disable != 0);
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::setDisabled(disable != 0);
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setDisabled(disable != 0);
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setDisabled(disable != 0);
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::setDisabled(disable != 0);
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::setDisabled(disable != 0);
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::setDisabled(disable != 0);
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setDisabled(disable != 0);
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::setDisabled(disable != 0);
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::setDisabled(disable != 0);
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::setDisabled(disable != 0);
	} else {
		static_cast<QWidget*>(ptr)->QWidget::setDisabled(disable != 0);
	}
}

void QWidget_SetEditFocus(void* ptr, char enable)
{
#ifdef QT_KEYPAD_NAVIGATION
		static_cast<QWidget*>(ptr)->setEditFocus(enable != 0);
#endif
}

void QWidget_SetEnabled(void* ptr, char vbo)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QWidget_SetEnabledDefault(void* ptr, char vbo)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::setEnabled(vbo != 0);
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::setEnabled(vbo != 0);
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::setEnabled(vbo != 0);
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setEnabled(vbo != 0);
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::setEnabled(vbo != 0);
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::setEnabled(vbo != 0);
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::setEnabled(vbo != 0);
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::setEnabled(vbo != 0);
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::setEnabled(vbo != 0);
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setEnabled(vbo != 0);
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::setEnabled(vbo != 0);
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setEnabled(vbo != 0);
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::setEnabled(vbo != 0);
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::setEnabled(vbo != 0);
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::setEnabled(vbo != 0);
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::setEnabled(vbo != 0);
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::setEnabled(vbo != 0);
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setEnabled(vbo != 0);
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setEnabled(vbo != 0);
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setEnabled(vbo != 0);
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::setEnabled(vbo != 0);
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::setEnabled(vbo != 0);
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::setEnabled(vbo != 0);
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::setEnabled(vbo != 0);
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setEnabled(vbo != 0);
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::setEnabled(vbo != 0);
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::setEnabled(vbo != 0);
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::setEnabled(vbo != 0);
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::setEnabled(vbo != 0);
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::setEnabled(vbo != 0);
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setEnabled(vbo != 0);
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::setEnabled(vbo != 0);
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::setEnabled(vbo != 0);
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::setEnabled(vbo != 0);
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::setEnabled(vbo != 0);
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::setEnabled(vbo != 0);
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setEnabled(vbo != 0);
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setEnabled(vbo != 0);
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setEnabled(vbo != 0);
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::setEnabled(vbo != 0);
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::setEnabled(vbo != 0);
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::setEnabled(vbo != 0);
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setEnabled(vbo != 0);
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::setEnabled(vbo != 0);
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setEnabled(vbo != 0);
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::setEnabled(vbo != 0);
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setEnabled(vbo != 0);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setEnabled(vbo != 0);
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::setEnabled(vbo != 0);
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::setEnabled(vbo != 0);
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::setEnabled(vbo != 0);
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setEnabled(vbo != 0);
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setEnabled(vbo != 0);
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::setEnabled(vbo != 0);
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::setEnabled(vbo != 0);
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::setEnabled(vbo != 0);
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::setEnabled(vbo != 0);
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::setEnabled(vbo != 0);
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::setEnabled(vbo != 0);
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setEnabled(vbo != 0);
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setEnabled(vbo != 0);
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::setEnabled(vbo != 0);
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::setEnabled(vbo != 0);
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::setEnabled(vbo != 0);
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setEnabled(vbo != 0);
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setEnabled(vbo != 0);
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::setEnabled(vbo != 0);
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::setEnabled(vbo != 0);
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::setEnabled(vbo != 0);
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setEnabled(vbo != 0);
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::setEnabled(vbo != 0);
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::setEnabled(vbo != 0);
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::setEnabled(vbo != 0);
	} else {
		static_cast<QWidget*>(ptr)->QWidget::setEnabled(vbo != 0);
	}
}

void QWidget_SetFixedHeight(void* ptr, int h)
{
		static_cast<QWidget*>(ptr)->setFixedHeight(h);
}

void QWidget_SetFixedSize(void* ptr, void* s)
{
		static_cast<QWidget*>(ptr)->setFixedSize(*static_cast<QSize*>(s));
}

void QWidget_SetFixedSize2(void* ptr, int w, int h)
{
		static_cast<QWidget*>(ptr)->setFixedSize(w, h);
}

void QWidget_SetFixedWidth(void* ptr, int w)
{
		static_cast<QWidget*>(ptr)->setFixedWidth(w);
}

void QWidget_SetFocus(void* ptr, long long reason)
{
		static_cast<QWidget*>(ptr)->setFocus(static_cast<Qt::FocusReason>(reason));
}

void QWidget_SetFocus2(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "setFocus");
}

void QWidget_SetFocus2Default(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::setFocus();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::setFocus();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::setFocus();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setFocus();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::setFocus();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::setFocus();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::setFocus();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::setFocus();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::setFocus();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setFocus();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::setFocus();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setFocus();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::setFocus();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::setFocus();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::setFocus();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::setFocus();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::setFocus();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setFocus();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setFocus();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setFocus();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::setFocus();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::setFocus();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::setFocus();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::setFocus();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setFocus();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::setFocus();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::setFocus();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::setFocus();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::setFocus();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::setFocus();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setFocus();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::setFocus();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::setFocus();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::setFocus();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::setFocus();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::setFocus();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setFocus();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setFocus();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setFocus();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::setFocus();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::setFocus();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::setFocus();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setFocus();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::setFocus();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setFocus();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::setFocus();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setFocus();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setFocus();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::setFocus();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::setFocus();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::setFocus();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setFocus();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setFocus();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::setFocus();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::setFocus();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::setFocus();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::setFocus();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::setFocus();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::setFocus();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setFocus();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setFocus();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::setFocus();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::setFocus();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::setFocus();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setFocus();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setFocus();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::setFocus();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::setFocus();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::setFocus();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setFocus();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::setFocus();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::setFocus();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::setFocus();
	} else {
		static_cast<QWidget*>(ptr)->QWidget::setFocus();
	}
}

void QWidget_SetFocusPolicy(void* ptr, long long policy)
{
		static_cast<QWidget*>(ptr)->setFocusPolicy(static_cast<Qt::FocusPolicy>(policy));
}

void QWidget_SetFocusProxy(void* ptr, void* w)
{
		static_cast<QWidget*>(ptr)->setFocusProxy(static_cast<QWidget*>(w));
}

void QWidget_SetFont(void* ptr, void* vqf)
{
		static_cast<QWidget*>(ptr)->setFont(*static_cast<QFont*>(vqf));
}

void QWidget_SetForegroundRole(void* ptr, long long role)
{
		static_cast<QWidget*>(ptr)->setForegroundRole(static_cast<QPalette::ColorRole>(role));
}

void QWidget_SetGeometry(void* ptr, void* vqr)
{
		static_cast<QWidget*>(ptr)->setGeometry(*static_cast<QRect*>(vqr));
}

void QWidget_SetGeometry2(void* ptr, int x, int y, int w, int h)
{
		static_cast<QWidget*>(ptr)->setGeometry(x, y, w, h);
}

void QWidget_SetGraphicsEffect(void* ptr, void* effect)
{
		static_cast<QWidget*>(ptr)->setGraphicsEffect(static_cast<QGraphicsEffect*>(effect));
}

void QWidget_SetHidden(void* ptr, char hidden)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QWidget_SetHiddenDefault(void* ptr, char hidden)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::setHidden(hidden != 0);
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::setHidden(hidden != 0);
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::setHidden(hidden != 0);
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setHidden(hidden != 0);
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::setHidden(hidden != 0);
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::setHidden(hidden != 0);
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::setHidden(hidden != 0);
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::setHidden(hidden != 0);
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::setHidden(hidden != 0);
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setHidden(hidden != 0);
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::setHidden(hidden != 0);
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setHidden(hidden != 0);
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::setHidden(hidden != 0);
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::setHidden(hidden != 0);
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::setHidden(hidden != 0);
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::setHidden(hidden != 0);
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::setHidden(hidden != 0);
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setHidden(hidden != 0);
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setHidden(hidden != 0);
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setHidden(hidden != 0);
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::setHidden(hidden != 0);
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::setHidden(hidden != 0);
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::setHidden(hidden != 0);
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::setHidden(hidden != 0);
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setHidden(hidden != 0);
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::setHidden(hidden != 0);
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::setHidden(hidden != 0);
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::setHidden(hidden != 0);
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::setHidden(hidden != 0);
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::setHidden(hidden != 0);
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setHidden(hidden != 0);
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::setHidden(hidden != 0);
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::setHidden(hidden != 0);
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::setHidden(hidden != 0);
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::setHidden(hidden != 0);
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::setHidden(hidden != 0);
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setHidden(hidden != 0);
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setHidden(hidden != 0);
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setHidden(hidden != 0);
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::setHidden(hidden != 0);
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::setHidden(hidden != 0);
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::setHidden(hidden != 0);
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setHidden(hidden != 0);
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::setHidden(hidden != 0);
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setHidden(hidden != 0);
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::setHidden(hidden != 0);
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setHidden(hidden != 0);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setHidden(hidden != 0);
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::setHidden(hidden != 0);
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::setHidden(hidden != 0);
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::setHidden(hidden != 0);
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setHidden(hidden != 0);
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setHidden(hidden != 0);
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::setHidden(hidden != 0);
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::setHidden(hidden != 0);
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::setHidden(hidden != 0);
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::setHidden(hidden != 0);
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::setHidden(hidden != 0);
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::setHidden(hidden != 0);
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setHidden(hidden != 0);
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setHidden(hidden != 0);
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::setHidden(hidden != 0);
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::setHidden(hidden != 0);
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::setHidden(hidden != 0);
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setHidden(hidden != 0);
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setHidden(hidden != 0);
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::setHidden(hidden != 0);
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::setHidden(hidden != 0);
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::setHidden(hidden != 0);
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setHidden(hidden != 0);
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::setHidden(hidden != 0);
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::setHidden(hidden != 0);
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::setHidden(hidden != 0);
	} else {
		static_cast<QWidget*>(ptr)->QWidget::setHidden(hidden != 0);
	}
}

void QWidget_SetInputMethodHints(void* ptr, long long hints)
{
		static_cast<QWidget*>(ptr)->setInputMethodHints(static_cast<Qt::InputMethodHint>(hints));
}

void QWidget_SetLayout(void* ptr, void* layout)
{
		static_cast<QWidget*>(ptr)->setLayout(static_cast<QLayout*>(layout));
}

void QWidget_SetLayoutDirection(void* ptr, long long direction)
{
		static_cast<QWidget*>(ptr)->setLayoutDirection(static_cast<Qt::LayoutDirection>(direction));
}

void QWidget_SetLocale(void* ptr, void* locale)
{
		static_cast<QWidget*>(ptr)->setLocale(*static_cast<QLocale*>(locale));
}

void QWidget_SetMask(void* ptr, void* bitmap)
{
		static_cast<QWidget*>(ptr)->setMask(*static_cast<QBitmap*>(bitmap));
}

void QWidget_SetMask2(void* ptr, void* region)
{
		static_cast<QWidget*>(ptr)->setMask(*static_cast<QRegion*>(region));
}

void QWidget_SetMaximumHeight(void* ptr, int maxh)
{
		static_cast<QWidget*>(ptr)->setMaximumHeight(maxh);
}

void QWidget_SetMaximumSize(void* ptr, void* vqs)
{
		static_cast<QWidget*>(ptr)->setMaximumSize(*static_cast<QSize*>(vqs));
}

void QWidget_SetMaximumSize2(void* ptr, int maxw, int maxh)
{
		static_cast<QWidget*>(ptr)->setMaximumSize(maxw, maxh);
}

void QWidget_SetMaximumWidth(void* ptr, int maxw)
{
		static_cast<QWidget*>(ptr)->setMaximumWidth(maxw);
}

void QWidget_SetMinimumHeight(void* ptr, int minh)
{
		static_cast<QWidget*>(ptr)->setMinimumHeight(minh);
}

void QWidget_SetMinimumSize(void* ptr, void* vqs)
{
		static_cast<QWidget*>(ptr)->setMinimumSize(*static_cast<QSize*>(vqs));
}

void QWidget_SetMinimumSize2(void* ptr, int minw, int minh)
{
		static_cast<QWidget*>(ptr)->setMinimumSize(minw, minh);
}

void QWidget_SetMinimumWidth(void* ptr, int minw)
{
		static_cast<QWidget*>(ptr)->setMinimumWidth(minw);
}

void QWidget_SetMouseTracking(void* ptr, char enable)
{
		static_cast<QWidget*>(ptr)->setMouseTracking(enable != 0);
}

void QWidget_SetPalette(void* ptr, void* vqp)
{
		static_cast<QWidget*>(ptr)->setPalette(*static_cast<QPalette*>(vqp));
}

void QWidget_SetParent(void* ptr, void* parent)
{
		static_cast<QWidget*>(ptr)->setParent(static_cast<QWidget*>(parent));
}

void QWidget_SetParent2(void* ptr, void* parent, long long ff)
{
		static_cast<QWidget*>(ptr)->setParent(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}

void QWidget_SetShortcutAutoRepeat(void* ptr, int id, char enable)
{
		static_cast<QWidget*>(ptr)->setShortcutAutoRepeat(id, enable != 0);
}

void QWidget_SetShortcutEnabled(void* ptr, int id, char enable)
{
		static_cast<QWidget*>(ptr)->setShortcutEnabled(id, enable != 0);
}

void QWidget_SetSizeIncrement(void* ptr, void* vqs)
{
		static_cast<QWidget*>(ptr)->setSizeIncrement(*static_cast<QSize*>(vqs));
}

void QWidget_SetSizeIncrement2(void* ptr, int w, int h)
{
		static_cast<QWidget*>(ptr)->setSizeIncrement(w, h);
}

void QWidget_SetSizePolicy(void* ptr, void* vqs)
{
		static_cast<QWidget*>(ptr)->setSizePolicy(*static_cast<QSizePolicy*>(vqs));
}

void QWidget_SetSizePolicy2(void* ptr, long long horizontal, long long vertical)
{
		static_cast<QWidget*>(ptr)->setSizePolicy(static_cast<QSizePolicy::Policy>(horizontal), static_cast<QSizePolicy::Policy>(vertical));
}

void QWidget_SetStatusTip(void* ptr, struct QtWidgets_PackedString vqs)
{
		static_cast<QWidget*>(ptr)->setStatusTip(QString::fromUtf8(vqs.data, vqs.len));
}

void QWidget_SetStyle(void* ptr, void* style)
{
		static_cast<QWidget*>(ptr)->setStyle(static_cast<QStyle*>(style));
}

void QWidget_SetStyleSheet(void* ptr, struct QtWidgets_PackedString styleSheet)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "setStyleSheet", Q_ARG(const QString, QString::fromUtf8(styleSheet.data, styleSheet.len)));
}

void QWidget_SetStyleSheetDefault(void* ptr, struct QtWidgets_PackedString styleSheet)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::setStyleSheet(QString::fromUtf8(styleSheet.data, styleSheet.len));
	}
}

void QWidget_QWidget_SetTabOrder(void* first, void* second)
{
		QWidget::setTabOrder(static_cast<QWidget*>(first), static_cast<QWidget*>(second));
}

void QWidget_SetTabletTracking(void* ptr, char enable)
{
		static_cast<QWidget*>(ptr)->setTabletTracking(enable != 0);
}

void QWidget_SetToolTip(void* ptr, struct QtWidgets_PackedString vqs)
{
		static_cast<QWidget*>(ptr)->setToolTip(QString::fromUtf8(vqs.data, vqs.len));
}

void QWidget_SetToolTipDuration(void* ptr, int msec)
{
		static_cast<QWidget*>(ptr)->setToolTipDuration(msec);
}

void QWidget_SetUpdatesEnabled(void* ptr, char enable)
{
		static_cast<QWidget*>(ptr)->setUpdatesEnabled(enable != 0);
}

void QWidget_SetVisible(void* ptr, char visible)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QWidget_SetVisibleDefault(void* ptr, char visible)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::setVisible(visible != 0);
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::setVisible(visible != 0);
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::setVisible(visible != 0);
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setVisible(visible != 0);
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::setVisible(visible != 0);
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::setVisible(visible != 0);
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::setVisible(visible != 0);
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::setVisible(visible != 0);
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::setVisible(visible != 0);
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setVisible(visible != 0);
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::setVisible(visible != 0);
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setVisible(visible != 0);
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::setVisible(visible != 0);
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::setVisible(visible != 0);
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::setVisible(visible != 0);
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::setVisible(visible != 0);
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::setVisible(visible != 0);
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setVisible(visible != 0);
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setVisible(visible != 0);
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setVisible(visible != 0);
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::setVisible(visible != 0);
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::setVisible(visible != 0);
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::setVisible(visible != 0);
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::setVisible(visible != 0);
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setVisible(visible != 0);
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::setVisible(visible != 0);
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::setVisible(visible != 0);
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::setVisible(visible != 0);
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::setVisible(visible != 0);
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::setVisible(visible != 0);
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setVisible(visible != 0);
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::setVisible(visible != 0);
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::setVisible(visible != 0);
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::setVisible(visible != 0);
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::setVisible(visible != 0);
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::setVisible(visible != 0);
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setVisible(visible != 0);
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setVisible(visible != 0);
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setVisible(visible != 0);
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::setVisible(visible != 0);
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::setVisible(visible != 0);
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::setVisible(visible != 0);
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setVisible(visible != 0);
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::setVisible(visible != 0);
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setVisible(visible != 0);
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::setVisible(visible != 0);
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setVisible(visible != 0);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setVisible(visible != 0);
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::setVisible(visible != 0);
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::setVisible(visible != 0);
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::setVisible(visible != 0);
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setVisible(visible != 0);
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setVisible(visible != 0);
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::setVisible(visible != 0);
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::setVisible(visible != 0);
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::setVisible(visible != 0);
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::setVisible(visible != 0);
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::setVisible(visible != 0);
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::setVisible(visible != 0);
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setVisible(visible != 0);
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setVisible(visible != 0);
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::setVisible(visible != 0);
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::setVisible(visible != 0);
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::setVisible(visible != 0);
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setVisible(visible != 0);
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setVisible(visible != 0);
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::setVisible(visible != 0);
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::setVisible(visible != 0);
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::setVisible(visible != 0);
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setVisible(visible != 0);
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::setVisible(visible != 0);
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::setVisible(visible != 0);
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::setVisible(visible != 0);
	} else {
		static_cast<QWidget*>(ptr)->QWidget::setVisible(visible != 0);
	}
}

void QWidget_SetWhatsThis(void* ptr, struct QtWidgets_PackedString vqs)
{
		static_cast<QWidget*>(ptr)->setWhatsThis(QString::fromUtf8(vqs.data, vqs.len));
}

void QWidget_SetWindowFilePath(void* ptr, struct QtWidgets_PackedString filePath)
{
		static_cast<QWidget*>(ptr)->setWindowFilePath(QString::fromUtf8(filePath.data, filePath.len));
}

void QWidget_SetWindowFlag(void* ptr, long long flag, char on)
{
		static_cast<QWidget*>(ptr)->setWindowFlag(static_cast<Qt::WindowType>(flag), on != 0);
}

void QWidget_SetWindowFlags(void* ptr, long long ty)
{
		static_cast<QWidget*>(ptr)->setWindowFlags(static_cast<Qt::WindowType>(ty));
}

void QWidget_SetWindowIcon(void* ptr, void* icon)
{
		static_cast<QWidget*>(ptr)->setWindowIcon(*static_cast<QIcon*>(icon));
}

void QWidget_SetWindowIconText(void* ptr, struct QtWidgets_PackedString vqs)
{
		static_cast<QWidget*>(ptr)->setWindowIconText(QString::fromUtf8(vqs.data, vqs.len));
}

void QWidget_SetWindowModality(void* ptr, long long windowModality)
{
		static_cast<QWidget*>(ptr)->setWindowModality(static_cast<Qt::WindowModality>(windowModality));
}

void QWidget_SetWindowModified(void* ptr, char vbo)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QWidget_SetWindowModifiedDefault(void* ptr, char vbo)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::setWindowModified(vbo != 0);
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::setWindowModified(vbo != 0);
	} else {
		static_cast<QWidget*>(ptr)->QWidget::setWindowModified(vbo != 0);
	}
}

void QWidget_SetWindowOpacity(void* ptr, double level)
{
		static_cast<QWidget*>(ptr)->setWindowOpacity(level);
}

void QWidget_SetWindowRole(void* ptr, struct QtWidgets_PackedString role)
{
		static_cast<QWidget*>(ptr)->setWindowRole(QString::fromUtf8(role.data, role.len));
}

void QWidget_SetWindowState(void* ptr, long long windowState)
{
		static_cast<QWidget*>(ptr)->setWindowState(static_cast<Qt::WindowState>(windowState));
}

void QWidget_SetWindowTitle(void* ptr, struct QtWidgets_PackedString vqs)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "setWindowTitle", Q_ARG(const QString, QString::fromUtf8(vqs.data, vqs.len)));
}

void QWidget_SetWindowTitleDefault(void* ptr, struct QtWidgets_PackedString vqs)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::setWindowTitle(QString::fromUtf8(vqs.data, vqs.len));
	}
}

void QWidget_SetupUi(void* ptr, void* widget)
{
#ifdef Q_QDOC
		static_cast<QWidget*>(ptr)->setupUi(static_cast<QWidget*>(widget));
#endif
}

void QWidget_Show(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "show");
}

void QWidget_ShowDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::show();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::show();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::show();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::show();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::show();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::show();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::show();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::show();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::show();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::show();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::show();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::show();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::show();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::show();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::show();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::show();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::show();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::show();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::show();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::show();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::show();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::show();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::show();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::show();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::show();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::show();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::show();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::show();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::show();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::show();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::show();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::show();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::show();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::show();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::show();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::show();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::show();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::show();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::show();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::show();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::show();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::show();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::show();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::show();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::show();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::show();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::show();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::show();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::show();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::show();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::show();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::show();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::show();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::show();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::show();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::show();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::show();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::show();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::show();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::show();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::show();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::show();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::show();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::show();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::show();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::show();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::show();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::show();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::show();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::show();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::show();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::show();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::show();
	} else {
		static_cast<QWidget*>(ptr)->QWidget::show();
	}
}

void QWidget_ShowEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QWidget_ShowEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::showEvent(static_cast<QShowEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::showEvent(static_cast<QShowEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::showEvent(static_cast<QShowEvent*>(event));
	}
}

void QWidget_ShowFullScreen(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "showFullScreen");
}

void QWidget_ShowFullScreenDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::showFullScreen();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::showFullScreen();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::showFullScreen();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::showFullScreen();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::showFullScreen();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::showFullScreen();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::showFullScreen();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::showFullScreen();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::showFullScreen();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::showFullScreen();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::showFullScreen();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::showFullScreen();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::showFullScreen();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::showFullScreen();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::showFullScreen();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::showFullScreen();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::showFullScreen();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::showFullScreen();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::showFullScreen();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::showFullScreen();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::showFullScreen();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::showFullScreen();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::showFullScreen();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::showFullScreen();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::showFullScreen();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::showFullScreen();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::showFullScreen();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::showFullScreen();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::showFullScreen();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::showFullScreen();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showFullScreen();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::showFullScreen();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::showFullScreen();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::showFullScreen();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::showFullScreen();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::showFullScreen();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::showFullScreen();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::showFullScreen();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::showFullScreen();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::showFullScreen();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::showFullScreen();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::showFullScreen();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::showFullScreen();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::showFullScreen();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::showFullScreen();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::showFullScreen();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::showFullScreen();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::showFullScreen();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::showFullScreen();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::showFullScreen();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::showFullScreen();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::showFullScreen();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::showFullScreen();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::showFullScreen();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::showFullScreen();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::showFullScreen();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::showFullScreen();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::showFullScreen();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::showFullScreen();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::showFullScreen();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::showFullScreen();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::showFullScreen();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::showFullScreen();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::showFullScreen();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::showFullScreen();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::showFullScreen();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::showFullScreen();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::showFullScreen();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::showFullScreen();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::showFullScreen();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::showFullScreen();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::showFullScreen();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::showFullScreen();
	} else {
		static_cast<QWidget*>(ptr)->QWidget::showFullScreen();
	}
}

void QWidget_ShowMaximized(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "showMaximized");
}

void QWidget_ShowMaximizedDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::showMaximized();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::showMaximized();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::showMaximized();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::showMaximized();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::showMaximized();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::showMaximized();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::showMaximized();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::showMaximized();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::showMaximized();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::showMaximized();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::showMaximized();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::showMaximized();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::showMaximized();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::showMaximized();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::showMaximized();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::showMaximized();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::showMaximized();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::showMaximized();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::showMaximized();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::showMaximized();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::showMaximized();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::showMaximized();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::showMaximized();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::showMaximized();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::showMaximized();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::showMaximized();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::showMaximized();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::showMaximized();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::showMaximized();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::showMaximized();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showMaximized();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::showMaximized();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::showMaximized();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::showMaximized();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::showMaximized();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::showMaximized();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::showMaximized();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::showMaximized();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::showMaximized();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::showMaximized();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::showMaximized();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::showMaximized();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::showMaximized();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::showMaximized();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::showMaximized();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::showMaximized();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::showMaximized();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::showMaximized();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::showMaximized();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::showMaximized();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::showMaximized();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::showMaximized();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::showMaximized();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::showMaximized();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::showMaximized();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::showMaximized();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::showMaximized();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::showMaximized();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::showMaximized();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::showMaximized();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::showMaximized();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::showMaximized();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::showMaximized();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::showMaximized();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::showMaximized();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::showMaximized();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::showMaximized();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::showMaximized();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::showMaximized();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::showMaximized();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::showMaximized();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::showMaximized();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::showMaximized();
	} else {
		static_cast<QWidget*>(ptr)->QWidget::showMaximized();
	}
}

void QWidget_ShowMinimized(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "showMinimized");
}

void QWidget_ShowMinimizedDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::showMinimized();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::showMinimized();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::showMinimized();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::showMinimized();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::showMinimized();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::showMinimized();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::showMinimized();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::showMinimized();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::showMinimized();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::showMinimized();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::showMinimized();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::showMinimized();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::showMinimized();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::showMinimized();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::showMinimized();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::showMinimized();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::showMinimized();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::showMinimized();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::showMinimized();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::showMinimized();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::showMinimized();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::showMinimized();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::showMinimized();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::showMinimized();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::showMinimized();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::showMinimized();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::showMinimized();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::showMinimized();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::showMinimized();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::showMinimized();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showMinimized();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::showMinimized();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::showMinimized();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::showMinimized();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::showMinimized();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::showMinimized();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::showMinimized();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::showMinimized();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::showMinimized();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::showMinimized();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::showMinimized();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::showMinimized();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::showMinimized();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::showMinimized();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::showMinimized();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::showMinimized();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::showMinimized();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::showMinimized();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::showMinimized();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::showMinimized();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::showMinimized();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::showMinimized();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::showMinimized();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::showMinimized();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::showMinimized();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::showMinimized();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::showMinimized();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::showMinimized();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::showMinimized();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::showMinimized();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::showMinimized();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::showMinimized();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::showMinimized();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::showMinimized();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::showMinimized();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::showMinimized();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::showMinimized();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::showMinimized();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::showMinimized();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::showMinimized();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::showMinimized();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::showMinimized();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::showMinimized();
	} else {
		static_cast<QWidget*>(ptr)->QWidget::showMinimized();
	}
}

void QWidget_ShowNormal(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "showNormal");
}

void QWidget_ShowNormalDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::showNormal();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::showNormal();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::showNormal();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::showNormal();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::showNormal();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::showNormal();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::showNormal();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::showNormal();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::showNormal();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::showNormal();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::showNormal();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::showNormal();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::showNormal();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::showNormal();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::showNormal();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::showNormal();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::showNormal();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::showNormal();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::showNormal();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::showNormal();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::showNormal();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::showNormal();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::showNormal();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::showNormal();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::showNormal();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::showNormal();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::showNormal();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::showNormal();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::showNormal();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::showNormal();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showNormal();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::showNormal();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::showNormal();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::showNormal();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::showNormal();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::showNormal();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::showNormal();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::showNormal();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::showNormal();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::showNormal();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::showNormal();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::showNormal();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::showNormal();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::showNormal();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::showNormal();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::showNormal();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::showNormal();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::showNormal();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::showNormal();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::showNormal();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::showNormal();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::showNormal();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::showNormal();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::showNormal();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::showNormal();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::showNormal();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::showNormal();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::showNormal();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::showNormal();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::showNormal();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::showNormal();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::showNormal();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::showNormal();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::showNormal();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::showNormal();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::showNormal();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::showNormal();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::showNormal();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::showNormal();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::showNormal();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::showNormal();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::showNormal();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::showNormal();
	} else {
		static_cast<QWidget*>(ptr)->QWidget::showNormal();
	}
}

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

void* QWidget_SizeHint(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWidget_SizeHintDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QWizardPage*>(ptr)->QWizardPage::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QToolBar*>(ptr)->QToolBar::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QStatusBar*>(ptr)->QStatusBar::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QSplashScreen*>(ptr)->QSplashScreen::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QSizeGrip*>(ptr)->QSizeGrip::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QMenuBar*>(ptr)->QMenuBar::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QMenu*>(ptr)->QMenu::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QMainWindow*>(ptr)->QMainWindow::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QLineEdit*>(ptr)->QLineEdit::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QGroupBox*>(ptr)->QGroupBox::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QProgressBar*>(ptr)->QProgressBar::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QFocusFrame*>(ptr)->QFocusFrame::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDockWidget*>(ptr)->QDockWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QFontComboBox*>(ptr)->QFontComboBox::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QComboBox*>(ptr)->QComboBox::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QWizard*>(ptr)->QWizard::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QMessageBox*>(ptr)->QMessageBox::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QInputDialog*>(ptr)->QInputDialog::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QProgressDialog*>(ptr)->QProgressDialog::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QFontDialog*>(ptr)->QFontDialog::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QFileDialog*>(ptr)->QFileDialog::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QErrorMessage*>(ptr)->QErrorMessage::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QColorDialog*>(ptr)->QColorDialog::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDialog*>(ptr)->QDialog::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QToolBox*>(ptr)->QToolBox::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QStackedWidget*>(ptr)->QStackedWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QSplitter*>(ptr)->QSplitter::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QLCDNumber*>(ptr)->QLCDNumber::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QLabel*>(ptr)->QLabel::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTextBrowser*>(ptr)->QTextBrowser::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTextEdit*>(ptr)->QTextEdit::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QMdiArea*>(ptr)->QMdiArea::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QGraphicsView*>(ptr)->QGraphicsView::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QScrollArea*>(ptr)->QScrollArea::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTreeWidget*>(ptr)->QTreeWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTreeView*>(ptr)->QTreeView::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTableWidget*>(ptr)->QTableWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTableView*>(ptr)->QTableView::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QUndoView*>(ptr)->QUndoView::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QListWidget*>(ptr)->QListWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QListView*>(ptr)->QListView::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QHeaderView*>(ptr)->QHeaderView::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QColumnView*>(ptr)->QColumnView::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QFrame*>(ptr)->QFrame::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QRubberBand*>(ptr)->QRubberBand::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTabBar*>(ptr)->QTabBar::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QScrollBar*>(ptr)->QScrollBar::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDial*>(ptr)->QDial::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QSlider*>(ptr)->QSlider::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QSpinBox*>(ptr)->QSpinBox::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDateEdit*>(ptr)->QDateEdit::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTimeEdit*>(ptr)->QTimeEdit::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QTabWidget*>(ptr)->QTabWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QToolButton*>(ptr)->QToolButton::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QRadioButton*>(ptr)->QRadioButton::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QPushButton*>(ptr)->QPushButton::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QCheckBox*>(ptr)->QCheckBox::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QAbstractButton*>(ptr)->QAbstractButton::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->QWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void* QWidget_SizeIncrement(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->sizeIncrement(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWidget_SizePolicy(void* ptr)
{
		return new QSizePolicy(static_cast<QWidget*>(ptr)->sizePolicy());
}

void QWidget_StackUnder(void* ptr, void* w)
{
		static_cast<QWidget*>(ptr)->stackUnder(static_cast<QWidget*>(w));
}

struct QtWidgets_PackedString QWidget_StatusTip(void* ptr)
{
		return ({ QByteArray* t96d9a1 = new QByteArray(static_cast<QWidget*>(ptr)->statusTip().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t96d9a1->prepend("WHITESPACE").constData()+10), t96d9a1->size()-10, t96d9a1 }; });
}

void* QWidget_Style(void* ptr)
{
		return static_cast<QWidget*>(ptr)->style();
}

struct QtWidgets_PackedString QWidget_StyleSheet(void* ptr)
{
		return ({ QByteArray* tb180d7 = new QByteArray(static_cast<QWidget*>(ptr)->styleSheet().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tb180d7->prepend("WHITESPACE").constData()+10), tb180d7->size()-10, tb180d7 }; });
}

void QWidget_TabletEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QWidget_TabletEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::tabletEvent(static_cast<QTabletEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::tabletEvent(static_cast<QTabletEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::tabletEvent(static_cast<QTabletEvent*>(event));
	}
}

char QWidget_TestAttribute(void* ptr, long long attribute)
{
		return static_cast<QWidget*>(ptr)->testAttribute(static_cast<Qt::WidgetAttribute>(attribute));
}

struct QtWidgets_PackedString QWidget_ToolTip(void* ptr)
{
		return ({ QByteArray* t791287 = new QByteArray(static_cast<QWidget*>(ptr)->toolTip().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t791287->prepend("WHITESPACE").constData()+10), t791287->size()-10, t791287 }; });
}

int QWidget_ToolTipDuration(void* ptr)
{
		return static_cast<QWidget*>(ptr)->toolTipDuration();
}

char QWidget_UnderMouse(void* ptr)
{
		return static_cast<QWidget*>(ptr)->underMouse();
}

void QWidget_UngrabGesture(void* ptr, long long gesture)
{
		static_cast<QWidget*>(ptr)->ungrabGesture(static_cast<Qt::GestureType>(gesture));
}

void QWidget_UnsetCursor(void* ptr)
{
		static_cast<QWidget*>(ptr)->unsetCursor();
}

void QWidget_UnsetLayoutDirection(void* ptr)
{
		static_cast<QWidget*>(ptr)->unsetLayoutDirection();
}

void QWidget_UnsetLocale(void* ptr)
{
		static_cast<QWidget*>(ptr)->unsetLocale();
}

void QWidget_Update(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "update");
}

void QWidget_UpdateDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::update();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::update();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::update();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::update();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::update();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::update();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::update();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::update();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::update();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::update();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::update();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::update();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::update();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::update();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::update();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::update();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::update();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::update();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::update();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::update();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::update();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::update();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::update();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::update();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::update();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::update();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::update();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::update();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::update();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::update();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::update();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::update();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::update();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::update();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::update();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::update();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::update();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::update();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::update();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::update();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::update();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::update();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::update();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::update();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::update();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::update();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::update();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::update();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::update();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::update();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::update();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::update();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::update();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::update();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::update();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::update();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::update();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::update();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::update();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::update();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::update();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::update();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::update();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::update();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::update();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::update();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::update();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::update();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::update();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::update();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::update();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::update();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::update();
	} else {
		static_cast<QWidget*>(ptr)->QWidget::update();
	}
}

void QWidget_Update2(void* ptr, int x, int y, int w, int h)
{
		static_cast<QWidget*>(ptr)->update(x, y, w, h);
}

void QWidget_Update3(void* ptr, void* rect)
{
		static_cast<QWidget*>(ptr)->update(*static_cast<QRect*>(rect));
}

void QWidget_Update4(void* ptr, void* rgn)
{
		static_cast<QWidget*>(ptr)->update(*static_cast<QRegion*>(rgn));
}

void QWidget_UpdateGeometry(void* ptr)
{
		static_cast<QWidget*>(ptr)->updateGeometry();
}

void QWidget_UpdateMicroFocus(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "updateMicroFocus");
}

void QWidget_UpdateMicroFocusDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::updateMicroFocus();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::updateMicroFocus();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::updateMicroFocus();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::updateMicroFocus();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::updateMicroFocus();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::updateMicroFocus();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::updateMicroFocus();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::updateMicroFocus();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::updateMicroFocus();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::updateMicroFocus();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::updateMicroFocus();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::updateMicroFocus();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::updateMicroFocus();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::updateMicroFocus();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::updateMicroFocus();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::updateMicroFocus();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::updateMicroFocus();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::updateMicroFocus();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::updateMicroFocus();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::updateMicroFocus();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::updateMicroFocus();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::updateMicroFocus();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::updateMicroFocus();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::updateMicroFocus();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::updateMicroFocus();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::updateMicroFocus();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::updateMicroFocus();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::updateMicroFocus();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::updateMicroFocus();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::updateMicroFocus();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::updateMicroFocus();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::updateMicroFocus();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::updateMicroFocus();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::updateMicroFocus();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::updateMicroFocus();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::updateMicroFocus();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::updateMicroFocus();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::updateMicroFocus();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::updateMicroFocus();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::updateMicroFocus();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::updateMicroFocus();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::updateMicroFocus();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::updateMicroFocus();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::updateMicroFocus();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::updateMicroFocus();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::updateMicroFocus();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::updateMicroFocus();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::updateMicroFocus();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::updateMicroFocus();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::updateMicroFocus();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::updateMicroFocus();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::updateMicroFocus();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::updateMicroFocus();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::updateMicroFocus();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::updateMicroFocus();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::updateMicroFocus();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::updateMicroFocus();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::updateMicroFocus();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::updateMicroFocus();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::updateMicroFocus();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::updateMicroFocus();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::updateMicroFocus();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::updateMicroFocus();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::updateMicroFocus();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::updateMicroFocus();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::updateMicroFocus();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::updateMicroFocus();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::updateMicroFocus();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::updateMicroFocus();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::updateMicroFocus();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::updateMicroFocus();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::updateMicroFocus();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::updateMicroFocus();
	} else {
		static_cast<QWidget*>(ptr)->QWidget::updateMicroFocus();
	}
}

char QWidget_UpdatesEnabled(void* ptr)
{
		return static_cast<QWidget*>(ptr)->updatesEnabled();
}

void* QWidget_VisibleRegion(void* ptr)
{
		return new QRegion(static_cast<QWidget*>(ptr)->visibleRegion());
}

struct QtWidgets_PackedString QWidget_WhatsThis(void* ptr)
{
		return ({ QByteArray* tb9ec26 = new QByteArray(static_cast<QWidget*>(ptr)->whatsThis().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tb9ec26->prepend("WHITESPACE").constData()+10), tb9ec26->size()-10, tb9ec26 }; });
}

void QWidget_WheelEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QWidget_WheelEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::wheelEvent(static_cast<QWheelEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::wheelEvent(static_cast<QWheelEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::wheelEvent(static_cast<QWheelEvent*>(event));
	}
}

int QWidget_Width(void* ptr)
{
		return static_cast<QWidget*>(ptr)->width();
}

uintptr_t QWidget_WinId(void* ptr)
{
		return static_cast<QWidget*>(ptr)->winId();
}

void* QWidget_Window(void* ptr)
{
		return static_cast<QWidget*>(ptr)->window();
}

struct QtWidgets_PackedString QWidget_WindowFilePath(void* ptr)
{
		return ({ QByteArray* tc809cf = new QByteArray(static_cast<QWidget*>(ptr)->windowFilePath().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tc809cf->prepend("WHITESPACE").constData()+10), tc809cf->size()-10, tc809cf }; });
}

long long QWidget_WindowFlags(void* ptr)
{
		return static_cast<QWidget*>(ptr)->windowFlags();
}

void* QWidget_WindowHandle(void* ptr)
{
		return static_cast<QWidget*>(ptr)->windowHandle();
}

void* QWidget_WindowIcon(void* ptr)
{
		return new QIcon(static_cast<QWidget*>(ptr)->windowIcon());
}

void QWidget_ConnectWindowIconChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QWidget*>(ptr), static_cast<void (QWidget::*)(const QIcon &)>(&QWidget::windowIconChanged), static_cast<MyQWidget*>(ptr), static_cast<void (MyQWidget::*)(const QIcon &)>(&MyQWidget::Signal_WindowIconChanged), static_cast<Qt::ConnectionType>(t));
}

void QWidget_DisconnectWindowIconChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWidget*>(ptr), static_cast<void (QWidget::*)(const QIcon &)>(&QWidget::windowIconChanged), static_cast<MyQWidget*>(ptr), static_cast<void (MyQWidget::*)(const QIcon &)>(&MyQWidget::Signal_WindowIconChanged));
}

void QWidget_WindowIconChanged(void* ptr, void* icon)
{
		static_cast<QWidget*>(ptr)->windowIconChanged(*static_cast<QIcon*>(icon));
}

struct QtWidgets_PackedString QWidget_WindowIconText(void* ptr)
{
		return ({ QByteArray* t309e48 = new QByteArray(static_cast<QWidget*>(ptr)->windowIconText().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t309e48->prepend("WHITESPACE").constData()+10), t309e48->size()-10, t309e48 }; });
}

long long QWidget_WindowModality(void* ptr)
{
		return static_cast<QWidget*>(ptr)->windowModality();
}

double QWidget_WindowOpacity(void* ptr)
{
		return static_cast<QWidget*>(ptr)->windowOpacity();
}

struct QtWidgets_PackedString QWidget_WindowRole(void* ptr)
{
		return ({ QByteArray* t64c9c6 = new QByteArray(static_cast<QWidget*>(ptr)->windowRole().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t64c9c6->prepend("WHITESPACE").constData()+10), t64c9c6->size()-10, t64c9c6 }; });
}

long long QWidget_WindowState(void* ptr)
{
		return static_cast<QWidget*>(ptr)->windowState();
}

struct QtWidgets_PackedString QWidget_WindowTitle(void* ptr)
{
		return ({ QByteArray* tf3cd6c = new QByteArray(static_cast<QWidget*>(ptr)->windowTitle().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tf3cd6c->prepend("WHITESPACE").constData()+10), tf3cd6c->size()-10, tf3cd6c }; });
}

void QWidget_ConnectWindowTitleChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QWidget*>(ptr), static_cast<void (QWidget::*)(const QString &)>(&QWidget::windowTitleChanged), static_cast<MyQWidget*>(ptr), static_cast<void (MyQWidget::*)(const QString &)>(&MyQWidget::Signal_WindowTitleChanged), static_cast<Qt::ConnectionType>(t));
}

void QWidget_DisconnectWindowTitleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWidget*>(ptr), static_cast<void (QWidget::*)(const QString &)>(&QWidget::windowTitleChanged), static_cast<MyQWidget*>(ptr), static_cast<void (MyQWidget::*)(const QString &)>(&MyQWidget::Signal_WindowTitleChanged));
}

void QWidget_WindowTitleChanged(void* ptr, struct QtWidgets_PackedString title)
{
		static_cast<QWidget*>(ptr)->windowTitleChanged(QString::fromUtf8(title.data, title.len));
}

long long QWidget_WindowType(void* ptr)
{
		return static_cast<QWidget*>(ptr)->windowType();
}

int QWidget_X(void* ptr)
{
		return static_cast<QWidget*>(ptr)->x();
}

int QWidget_Y(void* ptr)
{
		return static_cast<QWidget*>(ptr)->y();
}

void QWidget_DestroyQWidget(void* ptr)
{
	static_cast<QWidget*>(ptr)->~QWidget();
}

void QWidget_DestroyQWidgetDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QWidget___actions_atList(void* ptr, int i)
{
		return ({QAction * tmp = static_cast<QList<QAction *>*>(ptr)->at(i); if (i == static_cast<QList<QAction *>*>(ptr)->size()-1) { static_cast<QList<QAction *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QWidget___actions_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QAction *>();
}

void* QWidget___addActions_actions_atList(void* ptr, int i)
{
		return ({QAction * tmp = static_cast<QList<QAction *>*>(ptr)->at(i); if (i == static_cast<QList<QAction *>*>(ptr)->size()-1) { static_cast<QList<QAction *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QWidget___addActions_actions_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QAction *>();
}

void* QWidget___insertActions_actions_atList(void* ptr, int i)
{
		return ({QAction * tmp = static_cast<QList<QAction *>*>(ptr)->at(i); if (i == static_cast<QList<QAction *>*>(ptr)->size()-1) { static_cast<QList<QAction *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QWidget___insertActions_actions_newList(void* ptr)
{
	Q_UNUSED(ptr);
		return new QList<QAction *>();
}

void* QWidget___children_atList(void* ptr, int i)
{
		return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QWidget___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QWidget___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}

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

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

void* QWidget___findChildren_atList(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QWidget___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void* QWidget___findChildren_atList3(void* ptr, int i)
{
		return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

void QWidget___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsObject*>(i));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QGraphicsWidget*>(i));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QLayout*>(i));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWidget*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

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

void QWidget_ChildEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QWidget_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QWidget_ConnectNotify(void* ptr, void* sign)
{
		static_cast<QWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QWidget_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QWidget_CustomEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QWidget_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::customEvent(static_cast<QEvent*>(event));
	}
}

void QWidget_DeleteLater(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "deleteLater");
}

void QWidget_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::deleteLater();
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::deleteLater();
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::deleteLater();
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::deleteLater();
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::deleteLater();
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::deleteLater();
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::deleteLater();
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::deleteLater();
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::deleteLater();
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::deleteLater();
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::deleteLater();
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::deleteLater();
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::deleteLater();
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::deleteLater();
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::deleteLater();
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::deleteLater();
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::deleteLater();
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::deleteLater();
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::deleteLater();
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::deleteLater();
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::deleteLater();
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::deleteLater();
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::deleteLater();
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::deleteLater();
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::deleteLater();
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::deleteLater();
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::deleteLater();
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::deleteLater();
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::deleteLater();
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::deleteLater();
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::deleteLater();
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::deleteLater();
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::deleteLater();
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::deleteLater();
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::deleteLater();
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::deleteLater();
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::deleteLater();
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::deleteLater();
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::deleteLater();
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::deleteLater();
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::deleteLater();
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::deleteLater();
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::deleteLater();
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::deleteLater();
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::deleteLater();
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::deleteLater();
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::deleteLater();
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::deleteLater();
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::deleteLater();
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::deleteLater();
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::deleteLater();
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::deleteLater();
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::deleteLater();
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::deleteLater();
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::deleteLater();
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::deleteLater();
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::deleteLater();
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::deleteLater();
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::deleteLater();
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::deleteLater();
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::deleteLater();
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::deleteLater();
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::deleteLater();
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::deleteLater();
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::deleteLater();
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::deleteLater();
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::deleteLater();
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::deleteLater();
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::deleteLater();
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::deleteLater();
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::deleteLater();
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::deleteLater();
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::deleteLater();
	} else {
		static_cast<QWidget*>(ptr)->QWidget::deleteLater();
	}
}

void QWidget_DisconnectNotify(void* ptr, void* sign)
{
		static_cast<QWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QWidget_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

char QWidget_EventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
		return static_cast<QWidget*>(ptr)->eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QWidget*>(ptr)->eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
		return static_cast<QWidget*>(ptr)->eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
		return static_cast<QWidget*>(ptr)->eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

char QWidget_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QWizardPage*>(ptr)->QWizardPage::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QWizardPage*>(ptr)->QWizardPage::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QWizardPage*>(ptr)->QWizardPage::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QWizardPage*>(ptr)->QWizardPage::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QWizardPage*>(ptr)->QWizardPage::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QToolBar*>(ptr)->QToolBar::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QToolBar*>(ptr)->QToolBar::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QToolBar*>(ptr)->QToolBar::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QToolBar*>(ptr)->QToolBar::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QToolBar*>(ptr)->QToolBar::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QStatusBar*>(ptr)->QStatusBar::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QStatusBar*>(ptr)->QStatusBar::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QStatusBar*>(ptr)->QStatusBar::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QStatusBar*>(ptr)->QStatusBar::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QStatusBar*>(ptr)->QStatusBar::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QSplashScreen*>(ptr)->QSplashScreen::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSplashScreen*>(ptr)->QSplashScreen::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QSplashScreen*>(ptr)->QSplashScreen::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSplashScreen*>(ptr)->QSplashScreen::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QSplashScreen*>(ptr)->QSplashScreen::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QSizeGrip*>(ptr)->QSizeGrip::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSizeGrip*>(ptr)->QSizeGrip::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QSizeGrip*>(ptr)->QSizeGrip::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSizeGrip*>(ptr)->QSizeGrip::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QSizeGrip*>(ptr)->QSizeGrip::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QMenuBar*>(ptr)->QMenuBar::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMenuBar*>(ptr)->QMenuBar::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QMenuBar*>(ptr)->QMenuBar::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMenuBar*>(ptr)->QMenuBar::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMenuBar*>(ptr)->QMenuBar::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QMenu*>(ptr)->QMenu::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMenu*>(ptr)->QMenu::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QMenu*>(ptr)->QMenu::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMenu*>(ptr)->QMenu::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMenu*>(ptr)->QMenu::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QMainWindow*>(ptr)->QMainWindow::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMainWindow*>(ptr)->QMainWindow::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QMainWindow*>(ptr)->QMainWindow::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMainWindow*>(ptr)->QMainWindow::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMainWindow*>(ptr)->QMainWindow::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QLineEdit*>(ptr)->QLineEdit::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QLineEdit*>(ptr)->QLineEdit::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QLineEdit*>(ptr)->QLineEdit::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QLineEdit*>(ptr)->QLineEdit::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QLineEdit*>(ptr)->QLineEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGroupBox*>(ptr)->QGroupBox::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGroupBox*>(ptr)->QGroupBox::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGroupBox*>(ptr)->QGroupBox::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGroupBox*>(ptr)->QGroupBox::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGroupBox*>(ptr)->QGroupBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QProgressBar*>(ptr)->QProgressBar::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QProgressBar*>(ptr)->QProgressBar::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QProgressBar*>(ptr)->QProgressBar::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QProgressBar*>(ptr)->QProgressBar::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QProgressBar*>(ptr)->QProgressBar::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QFocusFrame*>(ptr)->QFocusFrame::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QFocusFrame*>(ptr)->QFocusFrame::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QFocusFrame*>(ptr)->QFocusFrame::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QFocusFrame*>(ptr)->QFocusFrame::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QFocusFrame*>(ptr)->QFocusFrame::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QDockWidget*>(ptr)->QDockWidget::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDockWidget*>(ptr)->QDockWidget::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QDockWidget*>(ptr)->QDockWidget::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDockWidget*>(ptr)->QDockWidget::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QDockWidget*>(ptr)->QDockWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QFontComboBox*>(ptr)->QFontComboBox::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QFontComboBox*>(ptr)->QFontComboBox::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QFontComboBox*>(ptr)->QFontComboBox::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QFontComboBox*>(ptr)->QFontComboBox::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QFontComboBox*>(ptr)->QFontComboBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QComboBox*>(ptr)->QComboBox::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QComboBox*>(ptr)->QComboBox::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QComboBox*>(ptr)->QComboBox::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QComboBox*>(ptr)->QComboBox::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QComboBox*>(ptr)->QComboBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QWizard*>(ptr)->QWizard::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QWizard*>(ptr)->QWizard::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QWizard*>(ptr)->QWizard::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QWizard*>(ptr)->QWizard::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QWizard*>(ptr)->QWizard::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QMessageBox*>(ptr)->QMessageBox::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMessageBox*>(ptr)->QMessageBox::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QMessageBox*>(ptr)->QMessageBox::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMessageBox*>(ptr)->QMessageBox::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMessageBox*>(ptr)->QMessageBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QInputDialog*>(ptr)->QInputDialog::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QInputDialog*>(ptr)->QInputDialog::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QInputDialog*>(ptr)->QInputDialog::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QInputDialog*>(ptr)->QInputDialog::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QInputDialog*>(ptr)->QInputDialog::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QProgressDialog*>(ptr)->QProgressDialog::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QProgressDialog*>(ptr)->QProgressDialog::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QProgressDialog*>(ptr)->QProgressDialog::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QProgressDialog*>(ptr)->QProgressDialog::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QProgressDialog*>(ptr)->QProgressDialog::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QFontDialog*>(ptr)->QFontDialog::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QFontDialog*>(ptr)->QFontDialog::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QFontDialog*>(ptr)->QFontDialog::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QFontDialog*>(ptr)->QFontDialog::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QFontDialog*>(ptr)->QFontDialog::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QFileDialog*>(ptr)->QFileDialog::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QFileDialog*>(ptr)->QFileDialog::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QFileDialog*>(ptr)->QFileDialog::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QFileDialog*>(ptr)->QFileDialog::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QFileDialog*>(ptr)->QFileDialog::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QErrorMessage*>(ptr)->QErrorMessage::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QErrorMessage*>(ptr)->QErrorMessage::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QErrorMessage*>(ptr)->QErrorMessage::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QErrorMessage*>(ptr)->QErrorMessage::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QErrorMessage*>(ptr)->QErrorMessage::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QColorDialog*>(ptr)->QColorDialog::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QColorDialog*>(ptr)->QColorDialog::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QColorDialog*>(ptr)->QColorDialog::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QColorDialog*>(ptr)->QColorDialog::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QColorDialog*>(ptr)->QColorDialog::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QDialog*>(ptr)->QDialog::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDialog*>(ptr)->QDialog::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QDialog*>(ptr)->QDialog::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDialog*>(ptr)->QDialog::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QDialog*>(ptr)->QDialog::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QToolBox*>(ptr)->QToolBox::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QToolBox*>(ptr)->QToolBox::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QToolBox*>(ptr)->QToolBox::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QToolBox*>(ptr)->QToolBox::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QToolBox*>(ptr)->QToolBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QStackedWidget*>(ptr)->QStackedWidget::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QStackedWidget*>(ptr)->QStackedWidget::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QStackedWidget*>(ptr)->QStackedWidget::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QStackedWidget*>(ptr)->QStackedWidget::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QStackedWidget*>(ptr)->QStackedWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QSplitter*>(ptr)->QSplitter::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSplitter*>(ptr)->QSplitter::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QSplitter*>(ptr)->QSplitter::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSplitter*>(ptr)->QSplitter::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QSplitter*>(ptr)->QSplitter::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QLCDNumber*>(ptr)->QLCDNumber::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QLCDNumber*>(ptr)->QLCDNumber::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QLCDNumber*>(ptr)->QLCDNumber::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QLCDNumber*>(ptr)->QLCDNumber::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QLCDNumber*>(ptr)->QLCDNumber::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QLabel*>(ptr)->QLabel::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QLabel*>(ptr)->QLabel::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QLabel*>(ptr)->QLabel::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QLabel*>(ptr)->QLabel::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QLabel*>(ptr)->QLabel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextBrowser*>(ptr)->QTextBrowser::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextBrowser*>(ptr)->QTextBrowser::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextBrowser*>(ptr)->QTextBrowser::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextBrowser*>(ptr)->QTextBrowser::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTextBrowser*>(ptr)->QTextBrowser::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextEdit*>(ptr)->QTextEdit::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextEdit*>(ptr)->QTextEdit::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextEdit*>(ptr)->QTextEdit::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextEdit*>(ptr)->QTextEdit::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTextEdit*>(ptr)->QTextEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QMdiArea*>(ptr)->QMdiArea::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMdiArea*>(ptr)->QMdiArea::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QMdiArea*>(ptr)->QMdiArea::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QMdiArea*>(ptr)->QMdiArea::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QMdiArea*>(ptr)->QMdiArea::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsView*>(ptr)->QGraphicsView::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsView*>(ptr)->QGraphicsView::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsView*>(ptr)->QGraphicsView::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QGraphicsView*>(ptr)->QGraphicsView::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QGraphicsView*>(ptr)->QGraphicsView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QScrollArea*>(ptr)->QScrollArea::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QScrollArea*>(ptr)->QScrollArea::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QScrollArea*>(ptr)->QScrollArea::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QScrollArea*>(ptr)->QScrollArea::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QScrollArea*>(ptr)->QScrollArea::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QTreeWidget*>(ptr)->QTreeWidget::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTreeWidget*>(ptr)->QTreeWidget::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QTreeWidget*>(ptr)->QTreeWidget::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTreeWidget*>(ptr)->QTreeWidget::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTreeWidget*>(ptr)->QTreeWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QTreeView*>(ptr)->QTreeView::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTreeView*>(ptr)->QTreeView::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QTreeView*>(ptr)->QTreeView::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTreeView*>(ptr)->QTreeView::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTreeView*>(ptr)->QTreeView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QTableWidget*>(ptr)->QTableWidget::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTableWidget*>(ptr)->QTableWidget::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QTableWidget*>(ptr)->QTableWidget::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTableWidget*>(ptr)->QTableWidget::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTableWidget*>(ptr)->QTableWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QTableView*>(ptr)->QTableView::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTableView*>(ptr)->QTableView::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QTableView*>(ptr)->QTableView::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTableView*>(ptr)->QTableView::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTableView*>(ptr)->QTableView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QUndoView*>(ptr)->QUndoView::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QUndoView*>(ptr)->QUndoView::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QUndoView*>(ptr)->QUndoView::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QUndoView*>(ptr)->QUndoView::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QUndoView*>(ptr)->QUndoView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QListWidget*>(ptr)->QListWidget::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QListWidget*>(ptr)->QListWidget::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QListWidget*>(ptr)->QListWidget::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QListWidget*>(ptr)->QListWidget::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QListWidget*>(ptr)->QListWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QListView*>(ptr)->QListView::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QListView*>(ptr)->QListView::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QListView*>(ptr)->QListView::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QListView*>(ptr)->QListView::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QListView*>(ptr)->QListView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QHeaderView*>(ptr)->QHeaderView::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QHeaderView*>(ptr)->QHeaderView::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QHeaderView*>(ptr)->QHeaderView::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QHeaderView*>(ptr)->QHeaderView::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QHeaderView*>(ptr)->QHeaderView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QColumnView*>(ptr)->QColumnView::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QColumnView*>(ptr)->QColumnView::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QColumnView*>(ptr)->QColumnView::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QColumnView*>(ptr)->QColumnView::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QColumnView*>(ptr)->QColumnView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QFrame*>(ptr)->QFrame::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QFrame*>(ptr)->QFrame::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QFrame*>(ptr)->QFrame::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QFrame*>(ptr)->QFrame::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QFrame*>(ptr)->QFrame::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QRubberBand*>(ptr)->QRubberBand::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QRubberBand*>(ptr)->QRubberBand::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QRubberBand*>(ptr)->QRubberBand::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QRubberBand*>(ptr)->QRubberBand::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QRubberBand*>(ptr)->QRubberBand::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QTabBar*>(ptr)->QTabBar::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTabBar*>(ptr)->QTabBar::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QTabBar*>(ptr)->QTabBar::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTabBar*>(ptr)->QTabBar::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTabBar*>(ptr)->QTabBar::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QScrollBar*>(ptr)->QScrollBar::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QScrollBar*>(ptr)->QScrollBar::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QScrollBar*>(ptr)->QScrollBar::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QScrollBar*>(ptr)->QScrollBar::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QScrollBar*>(ptr)->QScrollBar::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QDial*>(ptr)->QDial::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDial*>(ptr)->QDial::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QDial*>(ptr)->QDial::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDial*>(ptr)->QDial::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QDial*>(ptr)->QDial::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QSlider*>(ptr)->QSlider::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSlider*>(ptr)->QSlider::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QSlider*>(ptr)->QSlider::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSlider*>(ptr)->QSlider::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QSlider*>(ptr)->QSlider::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QSpinBox*>(ptr)->QSpinBox::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSpinBox*>(ptr)->QSpinBox::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QSpinBox*>(ptr)->QSpinBox::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QSpinBox*>(ptr)->QSpinBox::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QSpinBox*>(ptr)->QSpinBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QDateEdit*>(ptr)->QDateEdit::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDateEdit*>(ptr)->QDateEdit::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QDateEdit*>(ptr)->QDateEdit::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDateEdit*>(ptr)->QDateEdit::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QDateEdit*>(ptr)->QDateEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QTimeEdit*>(ptr)->QTimeEdit::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTimeEdit*>(ptr)->QTimeEdit::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QTimeEdit*>(ptr)->QTimeEdit::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTimeEdit*>(ptr)->QTimeEdit::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTimeEdit*>(ptr)->QTimeEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QTabWidget*>(ptr)->QTabWidget::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTabWidget*>(ptr)->QTabWidget::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QTabWidget*>(ptr)->QTabWidget::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QTabWidget*>(ptr)->QTabWidget::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTabWidget*>(ptr)->QTabWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QToolButton*>(ptr)->QToolButton::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QToolButton*>(ptr)->QToolButton::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QToolButton*>(ptr)->QToolButton::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QToolButton*>(ptr)->QToolButton::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QToolButton*>(ptr)->QToolButton::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioButton*>(ptr)->QRadioButton::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioButton*>(ptr)->QRadioButton::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioButton*>(ptr)->QRadioButton::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QRadioButton*>(ptr)->QRadioButton::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QRadioButton*>(ptr)->QRadioButton::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QPushButton*>(ptr)->QPushButton::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QPushButton*>(ptr)->QPushButton::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QPushButton*>(ptr)->QPushButton::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QPushButton*>(ptr)->QPushButton::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QPushButton*>(ptr)->QPushButton::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QCheckBox*>(ptr)->QCheckBox::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCheckBox*>(ptr)->QCheckBox::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QCheckBox*>(ptr)->QCheckBox::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QCheckBox*>(ptr)->QCheckBox::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QCheckBox*>(ptr)->QCheckBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractButton*>(ptr)->QAbstractButton::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractButton*>(ptr)->QAbstractButton::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractButton*>(ptr)->QAbstractButton::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QAbstractButton*>(ptr)->QAbstractButton::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QAbstractButton*>(ptr)->QAbstractButton::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(watched))) {
			return static_cast<QWidget*>(ptr)->QWidget::eventFilter(static_cast<QGraphicsObject*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QWidget*>(ptr)->QWidget::eventFilter(static_cast<QGraphicsWidget*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(watched))) {
			return static_cast<QWidget*>(ptr)->QWidget::eventFilter(static_cast<QLayout*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(watched))) {
			return static_cast<QWidget*>(ptr)->QWidget::eventFilter(static_cast<QWidget*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QWidget*>(ptr)->QWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void* QWidget_MetaObject(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QWidget*>(ptr)->metaObject());
}

void* QWidget_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QWizardPage*>(ptr)->QWizardPage::metaObject());
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QToolBar*>(ptr)->QToolBar::metaObject());
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QStatusBar*>(ptr)->QStatusBar::metaObject());
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::metaObject());
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QSplashScreen*>(ptr)->QSplashScreen::metaObject());
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QSizeGrip*>(ptr)->QSizeGrip::metaObject());
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::metaObject());
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMenuBar*>(ptr)->QMenuBar::metaObject());
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMenu*>(ptr)->QMenu::metaObject());
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::metaObject());
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMainWindow*>(ptr)->QMainWindow::metaObject());
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::metaObject());
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QLineEdit*>(ptr)->QLineEdit::metaObject());
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QGroupBox*>(ptr)->QGroupBox::metaObject());
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QProgressBar*>(ptr)->QProgressBar::metaObject());
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QFocusFrame*>(ptr)->QFocusFrame::metaObject());
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QDockWidget*>(ptr)->QDockWidget::metaObject());
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::metaObject());
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::metaObject());
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QFontComboBox*>(ptr)->QFontComboBox::metaObject());
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QComboBox*>(ptr)->QComboBox::metaObject());
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QWizard*>(ptr)->QWizard::metaObject());
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMessageBox*>(ptr)->QMessageBox::metaObject());
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QInputDialog*>(ptr)->QInputDialog::metaObject());
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QProgressDialog*>(ptr)->QProgressDialog::metaObject());
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QFontDialog*>(ptr)->QFontDialog::metaObject());
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QFileDialog*>(ptr)->QFileDialog::metaObject());
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QErrorMessage*>(ptr)->QErrorMessage::metaObject());
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QColorDialog*>(ptr)->QColorDialog::metaObject());
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QDialog*>(ptr)->QDialog::metaObject());
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::metaObject());
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QToolBox*>(ptr)->QToolBox::metaObject());
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QStackedWidget*>(ptr)->QStackedWidget::metaObject());
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QSplitter*>(ptr)->QSplitter::metaObject());
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QLCDNumber*>(ptr)->QLCDNumber::metaObject());
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QLabel*>(ptr)->QLabel::metaObject());
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::metaObject());
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTextBrowser*>(ptr)->QTextBrowser::metaObject());
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTextEdit*>(ptr)->QTextEdit::metaObject());
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QMdiArea*>(ptr)->QMdiArea::metaObject());
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QGraphicsView*>(ptr)->QGraphicsView::metaObject());
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QScrollArea*>(ptr)->QScrollArea::metaObject());
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::metaObject());
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTreeView*>(ptr)->QTreeView::metaObject());
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTableWidget*>(ptr)->QTableWidget::metaObject());
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTableView*>(ptr)->QTableView::metaObject());
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QUndoView*>(ptr)->QUndoView::metaObject());
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QListWidget*>(ptr)->QListWidget::metaObject());
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QListView*>(ptr)->QListView::metaObject());
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QHeaderView*>(ptr)->QHeaderView::metaObject());
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QColumnView*>(ptr)->QColumnView::metaObject());
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::metaObject());
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::metaObject());
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QFrame*>(ptr)->QFrame::metaObject());
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QRubberBand*>(ptr)->QRubberBand::metaObject());
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTabBar*>(ptr)->QTabBar::metaObject());
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QScrollBar*>(ptr)->QScrollBar::metaObject());
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QDial*>(ptr)->QDial::metaObject());
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QSlider*>(ptr)->QSlider::metaObject());
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::metaObject());
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::metaObject());
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QSpinBox*>(ptr)->QSpinBox::metaObject());
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QDateEdit*>(ptr)->QDateEdit::metaObject());
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTimeEdit*>(ptr)->QTimeEdit::metaObject());
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::metaObject());
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::metaObject());
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTabWidget*>(ptr)->QTabWidget::metaObject());
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QToolButton*>(ptr)->QToolButton::metaObject());
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QRadioButton*>(ptr)->QRadioButton::metaObject());
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::metaObject());
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QPushButton*>(ptr)->QPushButton::metaObject());
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QCheckBox*>(ptr)->QCheckBox::metaObject());
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QAbstractButton*>(ptr)->QAbstractButton::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QWidget*>(ptr)->QWidget::metaObject());
	}
}

void QWidget_TimerEvent(void* ptr, void* event)
{
		static_cast<QWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QWidget_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QWizardPage*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizardPage*>(ptr)->QWizardPage::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QToolBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBar*>(ptr)->QToolBar::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QStatusBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QStatusBar*>(ptr)->QStatusBar::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QSplitterHandle*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QSplashScreen*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplashScreen*>(ptr)->QSplashScreen::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QSizeGrip*>(static_cast<QObject*>(ptr))) {
		static_cast<QSizeGrip*>(ptr)->QSizeGrip::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QOpenGLWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QOpenGLWidget*>(ptr)->QOpenGLWidget::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMenuBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenuBar*>(ptr)->QMenuBar::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMenu*>(static_cast<QObject*>(ptr))) {
		static_cast<QMenu*>(ptr)->QMenu::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMdiSubWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMainWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QMainWindow*>(ptr)->QMainWindow::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QKeySequenceEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QLineEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QLineEdit*>(ptr)->QLineEdit::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QGroupBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QGroupBox*>(ptr)->QGroupBox::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QProgressBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressBar*>(ptr)->QProgressBar::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QFocusFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFocusFrame*>(ptr)->QFocusFrame::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QDockWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDockWidget*>(ptr)->QDockWidget::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QDialogButtonBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QDesktopWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QFontComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontComboBox*>(ptr)->QFontComboBox::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QComboBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QComboBox*>(ptr)->QComboBox::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QWizard*>(static_cast<QObject*>(ptr))) {
		static_cast<QWizard*>(ptr)->QWizard::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMessageBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QMessageBox*>(ptr)->QMessageBox::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QInputDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QInputDialog*>(ptr)->QInputDialog::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QProgressDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QProgressDialog*>(ptr)->QProgressDialog::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QFontDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFontDialog*>(ptr)->QFontDialog::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QFileDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QFileDialog*>(ptr)->QFileDialog::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QErrorMessage*>(static_cast<QObject*>(ptr))) {
		static_cast<QErrorMessage*>(ptr)->QErrorMessage::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QColorDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QColorDialog*>(ptr)->QColorDialog::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QDialog*>(static_cast<QObject*>(ptr))) {
		static_cast<QDialog*>(ptr)->QDialog::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCalendarWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QToolBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolBox*>(ptr)->QToolBox::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QStackedWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QStackedWidget*>(ptr)->QStackedWidget::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QSplitter*>(static_cast<QObject*>(ptr))) {
		static_cast<QSplitter*>(ptr)->QSplitter::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QLCDNumber*>(static_cast<QObject*>(ptr))) {
		static_cast<QLCDNumber*>(ptr)->QLCDNumber::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QLabel*>(static_cast<QObject*>(ptr))) {
		static_cast<QLabel*>(ptr)->QLabel::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QPlainTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBrowser*>(ptr)->QTextBrowser::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QTextEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextEdit*>(ptr)->QTextEdit::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QMdiArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QMdiArea*>(ptr)->QMdiArea::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QGraphicsView*>(static_cast<QObject*>(ptr))) {
		static_cast<QGraphicsView*>(ptr)->QGraphicsView::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollArea*>(ptr)->QScrollArea::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QTreeWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeWidget*>(ptr)->QTreeWidget::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QTreeView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTreeView*>(ptr)->QTreeView::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QTableWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableWidget*>(ptr)->QTableWidget::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QTableView*>(static_cast<QObject*>(ptr))) {
		static_cast<QTableView*>(ptr)->QTableView::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QUndoView*>(static_cast<QObject*>(ptr))) {
		static_cast<QUndoView*>(ptr)->QUndoView::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QListWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QListWidget*>(ptr)->QListWidget::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QListView*>(static_cast<QObject*>(ptr))) {
		static_cast<QListView*>(ptr)->QListView::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QHeaderView*>(static_cast<QObject*>(ptr))) {
		static_cast<QHeaderView*>(ptr)->QHeaderView::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QColumnView*>(static_cast<QObject*>(ptr))) {
		static_cast<QColumnView*>(ptr)->QColumnView::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QAbstractItemView*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QAbstractScrollArea*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QFrame*>(ptr)->QFrame::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QRubberBand*>(static_cast<QObject*>(ptr))) {
		static_cast<QRubberBand*>(ptr)->QRubberBand::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QTabBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabBar*>(ptr)->QTabBar::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QScrollBar*>(static_cast<QObject*>(ptr))) {
		static_cast<QScrollBar*>(ptr)->QScrollBar::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QDial*>(static_cast<QObject*>(ptr))) {
		static_cast<QDial*>(ptr)->QDial::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QSlider*>(ptr)->QSlider::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QAbstractSlider*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QDoubleSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QSpinBox*>(ptr)->QSpinBox::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateEdit*>(ptr)->QDateEdit::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QTimeEdit*>(ptr)->QTimeEdit::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QDateTimeEdit*>(static_cast<QObject*>(ptr))) {
		static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QAbstractSpinBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QTabWidget*>(static_cast<QObject*>(ptr))) {
		static_cast<QTabWidget*>(ptr)->QTabWidget::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QToolButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QToolButton*>(ptr)->QToolButton::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QRadioButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QRadioButton*>(ptr)->QRadioButton::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCommandLinkButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QPushButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QPushButton*>(ptr)->QPushButton::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QCheckBox*>(static_cast<QObject*>(ptr))) {
		static_cast<QCheckBox*>(ptr)->QCheckBox::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QAbstractButton*>(static_cast<QObject*>(ptr))) {
		static_cast<QAbstractButton*>(ptr)->QAbstractButton::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QWidget*>(ptr)->QWidget::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

class MyQWidgetAction: public QWidgetAction
{
public:
	MyQWidgetAction(QObject *parent) : QWidgetAction(parent) {QWidgetAction_QWidgetAction_QRegisterMetaType();};
	QWidget * createWidget(QWidget * parent) { return static_cast<QWidget*>(callbackQWidgetAction_CreateWidget(this, parent)); };
	void deleteWidget(QWidget * widget) { callbackQWidgetAction_DeleteWidget(this, widget); };
	bool event(QEvent * event) { return callbackQAction_Event(this, event) != 0; };
	bool eventFilter(QObject * obj, QEvent * event) { return callbackQAction_EventFilter(this, obj, event) != 0; };
	 ~MyQWidgetAction() { callbackQWidgetAction_DestroyQWidgetAction(this); };
	void Signal_Changed() { callbackQAction_Changed(this); };
	void hover() { callbackQAction_Hover(this); };
	void Signal_Hovered() { callbackQAction_Hovered(this); };
	void setChecked(bool vbo) { callbackQAction_SetChecked(this, vbo); };
	void setDisabled(bool b) { callbackQAction_SetDisabled(this, b); };
	void setEnabled(bool vbo) { callbackQAction_SetEnabled(this, vbo); };
	void setVisible(bool vbo) { callbackQAction_SetVisible(this, vbo); };
	void toggle() { callbackQAction_Toggle(this); };
	void Signal_Toggled(bool checked) { callbackQAction_Toggled(this, checked); };
	void trigger() { callbackQAction_Trigger(this); };
	void Signal_Triggered(bool checked) { callbackQAction_Triggered(this, checked); };
	void childEvent(QChildEvent * event) { callbackQAction_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAction_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAction_CustomEvent(this, event); };
	void deleteLater() { callbackQAction_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAction_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAction_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAction_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQAction_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAction_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QWidgetAction*)
Q_DECLARE_METATYPE(MyQWidgetAction*)

int QWidgetAction_QWidgetAction_QRegisterMetaType(){qRegisterMetaType<QWidgetAction*>(); return qRegisterMetaType<MyQWidgetAction*>();}

void* QWidgetAction_NewQWidgetAction(void* parent)
{
	if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QAudioSystemPlugin*>(parent));
	} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QCameraImageCapture*>(parent));
	} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QDBusPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QExtensionFactory*>(parent));
	} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QExtensionManager*>(parent));
	} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QGraphicsObject*>(parent));
	} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QGraphicsWidget*>(parent));
	} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QLayout*>(parent));
	} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QMediaPlaylist*>(parent));
	} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QMediaRecorder*>(parent));
	} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QMediaServiceProviderPlugin*>(parent));
	} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QQuickItem*>(parent));
	} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QRadioData*>(parent));
	} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
	} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QScriptExtensionPlugin*>(parent));
	} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QWidget*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return new MyQWidgetAction(static_cast<QWindow*>(parent));
	} else {
		return new MyQWidgetAction(static_cast<QObject*>(parent));
	}
}

void* QWidgetAction_CreateWidget(void* ptr, void* parent)
{
		return static_cast<QWidgetAction*>(ptr)->createWidget(static_cast<QWidget*>(parent));
}

void* QWidgetAction_CreateWidgetDefault(void* ptr, void* parent)
{
		return static_cast<QWidgetAction*>(ptr)->QWidgetAction::createWidget(static_cast<QWidget*>(parent));
}

struct QtWidgets_PackedList QWidgetAction_CreatedWidgets(void* ptr)
{
	return ({ QList<QWidget *>* tmpValued33f9e = new QList<QWidget *>(static_cast<QWidgetAction*>(ptr)->createdWidgets()); QtWidgets_PackedList { tmpValued33f9e, tmpValued33f9e->size() }; });
}

void* QWidgetAction_DefaultWidget(void* ptr)
{
	return static_cast<QWidgetAction*>(ptr)->defaultWidget();
}

void QWidgetAction_DeleteWidget(void* ptr, void* widget)
{
		static_cast<QWidgetAction*>(ptr)->deleteWidget(static_cast<QWidget*>(widget));
}

void QWidgetAction_DeleteWidgetDefault(void* ptr, void* widget)
{
		static_cast<QWidgetAction*>(ptr)->QWidgetAction::deleteWidget(static_cast<QWidget*>(widget));
}

void QWidgetAction_ReleaseWidget(void* ptr, void* widget)
{
		static_cast<QWidgetAction*>(ptr)->releaseWidget(static_cast<QWidget*>(widget));
}

void* QWidgetAction_RequestWidget(void* ptr, void* parent)
{
		return static_cast<QWidgetAction*>(ptr)->requestWidget(static_cast<QWidget*>(parent));
}

void QWidgetAction_SetDefaultWidget(void* ptr, void* widget)
{
		static_cast<QWidgetAction*>(ptr)->setDefaultWidget(static_cast<QWidget*>(widget));
}

void QWidgetAction_DestroyQWidgetAction(void* ptr)
{
	static_cast<QWidgetAction*>(ptr)->~QWidgetAction();
}

void QWidgetAction_DestroyQWidgetActionDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

void* QWidgetAction___createdWidgets_atList(void* ptr, int i)
{
	return ({QWidget * tmp = static_cast<QList<QWidget *>*>(ptr)->at(i); if (i == static_cast<QList<QWidget *>*>(ptr)->size()-1) { static_cast<QList<QWidget *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

void* QWidgetAction___createdWidgets_newList(void* ptr)
{
	Q_UNUSED(ptr);
	return new QList<QWidget *>();
}

class MyQWidgetItem: public QWidgetItem
{
public:
	MyQWidgetItem(QWidget *widget) : QWidgetItem(widget) {QWidgetItem_QWidgetItem_QRegisterMetaType();};
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayoutItem_ControlTypes(const_cast<void*>(static_cast<const void*>(this)))); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQWidgetItem_ExpandingDirections(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQWidgetItem_Geometry(const_cast<void*>(static_cast<const void*>(this)))); };
	bool hasHeightForWidth() const { return callbackQLayoutItem_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQLayoutItem_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	bool isEmpty() const { return callbackQWidgetItem_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQWidgetItem_MaximumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQWidgetItem_MinimumSize(const_cast<void*>(static_cast<const void*>(this)))); };
	void setGeometry(const QRect & rect) { callbackQWidgetItem_SetGeometry(this, const_cast<QRect*>(&rect)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidgetItem_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQLayoutItem_Widget(this)); };
	 ~MyQWidgetItem() { callbackQWidgetItem_DestroyQWidgetItem(this); };
	void invalidate() { callbackQLayoutItem_Invalidate(this); };
	QLayout * layout() { return static_cast<QLayout*>(callbackQLayoutItem_Layout(this)); };
	int minimumHeightForWidth(int w) const { return callbackQLayoutItem_MinimumHeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayoutItem_SpacerItem(this)); };
};

Q_DECLARE_METATYPE(QWidgetItem*)
Q_DECLARE_METATYPE(MyQWidgetItem*)

int QWidgetItem_QWidgetItem_QRegisterMetaType(){qRegisterMetaType<QWidgetItem*>(); return qRegisterMetaType<MyQWidgetItem*>();}

void* QWidgetItem_NewQWidgetItem2(void* widget)
{
		return new MyQWidgetItem(static_cast<QWidget*>(widget));
}

long long QWidgetItem_ExpandingDirections(void* ptr)
{
	return static_cast<QWidgetItem*>(ptr)->expandingDirections();
}

long long QWidgetItem_ExpandingDirectionsDefault(void* ptr)
{
		return static_cast<QWidgetItem*>(ptr)->QWidgetItem::expandingDirections();
}

void* QWidgetItem_Geometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QWidgetItem*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

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

char QWidgetItem_IsEmpty(void* ptr)
{
	return static_cast<QWidgetItem*>(ptr)->isEmpty();
}

char QWidgetItem_IsEmptyDefault(void* ptr)
{
		return static_cast<QWidgetItem*>(ptr)->QWidgetItem::isEmpty();
}

void* QWidgetItem_MaximumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWidgetItem*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWidgetItem_MaximumSizeDefault(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QWidgetItem*>(ptr)->QWidgetItem::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWidgetItem_MinimumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWidgetItem*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWidgetItem_MinimumSizeDefault(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QWidgetItem*>(ptr)->QWidgetItem::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QWidgetItem_SetGeometry(void* ptr, void* rect)
{
	static_cast<QWidgetItem*>(ptr)->setGeometry(*static_cast<QRect*>(rect));
}

void QWidgetItem_SetGeometryDefault(void* ptr, void* rect)
{
		static_cast<QWidgetItem*>(ptr)->QWidgetItem::setGeometry(*static_cast<QRect*>(rect));
}

void* QWidgetItem_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWidgetItem*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWidgetItem_SizeHintDefault(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QWidgetItem*>(ptr)->QWidgetItem::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QWidgetItem_DestroyQWidgetItem(void* ptr)
{
	static_cast<QWidgetItem*>(ptr)->~QWidgetItem();
}

void QWidgetItem_DestroyQWidgetItemDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

class MyQWizard: public QWizard
{
public:
	MyQWizard(QWidget *parent = Q_NULLPTR, Qt::WindowFlags flags = Qt::WindowFlags()) : QWizard(parent, flags) {QWizard_QWizard_QRegisterMetaType();};
	void back() { callbackQWizard_Back(this); };
	void cleanupPage(int id) { callbackQWizard_CleanupPage(this, id); };
	void Signal_CurrentIdChanged(int id) { callbackQWizard_CurrentIdChanged(this, id); };
	void Signal_CustomButtonClicked(int which) { callbackQWizard_CustomButtonClicked(this, which); };
	void done(int result) { callbackQWizard_Done(this, result); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void Signal_HelpRequested() { callbackQWizard_HelpRequested(this); };
	void initializePage(int id) { callbackQWizard_InitializePage(this, id); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	void next() { callbackQWizard_Next(this); };
	int nextId() const { return callbackQWizard_NextId(const_cast<void*>(static_cast<const void*>(this))); };
	void Signal_PageAdded(int id) { callbackQWizard_PageAdded(this, id); };
	void Signal_PageRemoved(int id) { callbackQWizard_PageRemoved(this, id); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void restart() { callbackQWizard_Restart(this); };
	void setVisible(bool visible) { callbackQDialog_SetVisible(this, visible); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	bool validateCurrentPage() { return callbackQWizard_ValidateCurrentPage(this) != 0; };
	 ~MyQWizard() { callbackQWizard_DestroyQWizard(this); };
	void accept() { callbackQDialog_Accept(this); };
	void Signal_Accepted() { callbackQDialog_Accepted(this); };
	void closeEvent(QCloseEvent * e) { callbackQWidget_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWidget_ContextMenuEvent(this, e); };
	bool eventFilter(QObject * o, QEvent * e) { return callbackQWidget_EventFilter(this, o, e) != 0; };
	int exec() { return callbackQDialog_Exec(this); };
	void Signal_Finished(int result) { callbackQDialog_Finished(this, result); };
	void keyPressEvent(QKeyEvent * e) { callbackQWidget_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void open() { callbackQDialog_Open(this); };
	void reject() { callbackQDialog_Reject(this); };
	void Signal_Rejected() { callbackQDialog_Rejected(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QWizard*)
Q_DECLARE_METATYPE(MyQWizard*)

int QWizard_QWizard_QRegisterMetaType(){qRegisterMetaType<QWizard*>(); return qRegisterMetaType<MyQWizard*>();}

void* QWizard_NewQWizard(void* parent, long long flags)
{
		return new MyQWizard(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}

int QWizard_AddPage(void* ptr, void* page)
{
	return static_cast<QWizard*>(ptr)->addPage(static_cast<QWizardPage*>(page));
}

void QWizard_Back(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "back");
}

void QWizard_BackDefault(void* ptr)
{
		static_cast<QWizard*>(ptr)->QWizard::back();
}

void* QWizard_Button(void* ptr, long long which)
{
	return static_cast<QWizard*>(ptr)->button(static_cast<QWizard::WizardButton>(which));
}

struct QtWidgets_PackedString QWizard_ButtonText(void* ptr, long long which)
{
	return ({ QByteArray* tdb6a3d = new QByteArray(static_cast<QWizard*>(ptr)->buttonText(static_cast<QWizard::WizardButton>(which)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(tdb6a3d->prepend("WHITESPACE").constData()+10), tdb6a3d->size()-10, tdb6a3d }; });
}

void QWizard_CleanupPage(void* ptr, int id)
{
	static_cast<QWizard*>(ptr)->cleanupPage(id);
}

void QWizard_CleanupPageDefault(void* ptr, int id)
{
		static_cast<QWizard*>(ptr)->QWizard::cleanupPage(id);
}

int QWizard_CurrentId(void* ptr)
{
	return static_cast<QWizard*>(ptr)->currentId();
}

void QWizard_ConnectCurrentIdChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QWizard*>(ptr), static_cast<void (QWizard::*)(int)>(&QWizard::currentIdChanged), static_cast<MyQWizard*>(ptr), static_cast<void (MyQWizard::*)(int)>(&MyQWizard::Signal_CurrentIdChanged), static_cast<Qt::ConnectionType>(t));
}

void QWizard_DisconnectCurrentIdChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWizard*>(ptr), static_cast<void (QWizard::*)(int)>(&QWizard::currentIdChanged), static_cast<MyQWizard*>(ptr), static_cast<void (MyQWizard::*)(int)>(&MyQWizard::Signal_CurrentIdChanged));
}

void QWizard_CurrentIdChanged(void* ptr, int id)
{
	static_cast<QWizard*>(ptr)->currentIdChanged(id);
}

void* QWizard_CurrentPage(void* ptr)
{
	return static_cast<QWizard*>(ptr)->currentPage();
}

void QWizard_ConnectCustomButtonClicked(void* ptr, long long t)
{
	QObject::connect(static_cast<QWizard*>(ptr), static_cast<void (QWizard::*)(int)>(&QWizard::customButtonClicked), static_cast<MyQWizard*>(ptr), static_cast<void (MyQWizard::*)(int)>(&MyQWizard::Signal_CustomButtonClicked), static_cast<Qt::ConnectionType>(t));
}

void QWizard_DisconnectCustomButtonClicked(void* ptr)
{
	QObject::disconnect(static_cast<QWizard*>(ptr), static_cast<void (QWizard::*)(int)>(&QWizard::customButtonClicked), static_cast<MyQWizard*>(ptr), static_cast<void (MyQWizard::*)(int)>(&MyQWizard::Signal_CustomButtonClicked));
}

void QWizard_CustomButtonClicked(void* ptr, int which)
{
	static_cast<QWizard*>(ptr)->customButtonClicked(which);
}

void QWizard_Done(void* ptr, int result)
{
	static_cast<QWizard*>(ptr)->done(result);
}

void QWizard_DoneDefault(void* ptr, int result)
{
		static_cast<QWizard*>(ptr)->QWizard::done(result);
}

void* QWizard_Field(void* ptr, struct QtWidgets_PackedString name)
{
	return new QVariant(static_cast<QWizard*>(ptr)->field(QString::fromUtf8(name.data, name.len)));
}

char QWizard_HasVisitedPage(void* ptr, int id)
{
	return static_cast<QWizard*>(ptr)->hasVisitedPage(id);
}

void QWizard_ConnectHelpRequested(void* ptr, long long t)
{
	QObject::connect(static_cast<QWizard*>(ptr), static_cast<void (QWizard::*)()>(&QWizard::helpRequested), static_cast<MyQWizard*>(ptr), static_cast<void (MyQWizard::*)()>(&MyQWizard::Signal_HelpRequested), static_cast<Qt::ConnectionType>(t));
}

void QWizard_DisconnectHelpRequested(void* ptr)
{
	QObject::disconnect(static_cast<QWizard*>(ptr), static_cast<void (QWizard::*)()>(&QWizard::helpRequested), static_cast<MyQWizard*>(ptr), static_cast<void (MyQWizard::*)()>(&MyQWizard::Signal_HelpRequested));
}

void QWizard_HelpRequested(void* ptr)
{
	static_cast<QWizard*>(ptr)->helpRequested();
}

void QWizard_InitializePage(void* ptr, int id)
{
	static_cast<QWizard*>(ptr)->initializePage(id);
}

void QWizard_InitializePageDefault(void* ptr, int id)
{
		static_cast<QWizard*>(ptr)->QWizard::initializePage(id);
}

void QWizard_Next(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "next");
}

void QWizard_NextDefault(void* ptr)
{
		static_cast<QWizard*>(ptr)->QWizard::next();
}

int QWizard_NextId(void* ptr)
{
	return static_cast<QWizard*>(ptr)->nextId();
}

int QWizard_NextIdDefault(void* ptr)
{
		return static_cast<QWizard*>(ptr)->QWizard::nextId();
}

long long QWizard_Options(void* ptr)
{
	return static_cast<QWizard*>(ptr)->options();
}

void* QWizard_Page(void* ptr, int id)
{
	return static_cast<QWizard*>(ptr)->page(id);
}

void QWizard_ConnectPageAdded(void* ptr, long long t)
{
	QObject::connect(static_cast<QWizard*>(ptr), static_cast<void (QWizard::*)(int)>(&QWizard::pageAdded), static_cast<MyQWizard*>(ptr), static_cast<void (MyQWizard::*)(int)>(&MyQWizard::Signal_PageAdded), static_cast<Qt::ConnectionType>(t));
}

void QWizard_DisconnectPageAdded(void* ptr)
{
	QObject::disconnect(static_cast<QWizard*>(ptr), static_cast<void (QWizard::*)(int)>(&QWizard::pageAdded), static_cast<MyQWizard*>(ptr), static_cast<void (MyQWizard::*)(int)>(&MyQWizard::Signal_PageAdded));
}

void QWizard_PageAdded(void* ptr, int id)
{
	static_cast<QWizard*>(ptr)->pageAdded(id);
}

struct QtWidgets_PackedList QWizard_PageIds(void* ptr)
{
	return ({ QList<int>* tmpValuec08e79 = new QList<int>(static_cast<QWizard*>(ptr)->pageIds()); QtWidgets_PackedList { tmpValuec08e79, tmpValuec08e79->size() }; });
}

void QWizard_ConnectPageRemoved(void* ptr, long long t)
{
	QObject::connect(static_cast<QWizard*>(ptr), static_cast<void (QWizard::*)(int)>(&QWizard::pageRemoved), static_cast<MyQWizard*>(ptr), static_cast<void (MyQWizard::*)(int)>(&MyQWizard::Signal_PageRemoved), static_cast<Qt::ConnectionType>(t));
}

void QWizard_DisconnectPageRemoved(void* ptr)
{
	QObject::disconnect(static_cast<QWizard*>(ptr), static_cast<void (QWizard::*)(int)>(&QWizard::pageRemoved), static_cast<MyQWizard*>(ptr), static_cast<void (MyQWizard::*)(int)>(&MyQWizard::Signal_PageRemoved));
}

void QWizard_PageRemoved(void* ptr, int id)
{
	static_cast<QWizard*>(ptr)->pageRemoved(id);
}

void* QWizard_Pixmap(void* ptr, long long which)
{
	return new QPixmap(static_cast<QWizard*>(ptr)->pixmap(static_cast<QWizard::WizardPixmap>(which)));
}

void QWizard_RemovePage(void* ptr, int id)
{
	static_cast<QWizard*>(ptr)->removePage(id);
}

void QWizard_Restart(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "restart");
}

void QWizard_RestartDefault(void* ptr)
{
		static_cast<QWizard*>(ptr)->QWizard::restart();
}

void QWizard_SetButton(void* ptr, long long which, void* button)
{
	static_cast<QWizard*>(ptr)->setButton(static_cast<QWizard::WizardButton>(which), static_cast<QAbstractButton*>(button));
}

void QWizard_SetButtonText(void* ptr, long long which, struct QtWidgets_PackedString text)
{
	static_cast<QWizard*>(ptr)->setButtonText(static_cast<QWizard::WizardButton>(which), QString::fromUtf8(text.data, text.len));
}

void QWizard_SetDefaultProperty(void* ptr, char* className, char* property, char* changedSignal)
{
	static_cast<QWizard*>(ptr)->setDefaultProperty(const_cast<const char*>(className), const_cast<const char*>(property), const_cast<const char*>(changedSignal));
}

void QWizard_SetField(void* ptr, struct QtWidgets_PackedString name, void* value)
{
	static_cast<QWizard*>(ptr)->setField(QString::fromUtf8(name.data, name.len), *static_cast<QVariant*>(value));
}

void QWizard_SetOption(void* ptr, long long option, char on)
{
	static_cast<QWizard*>(ptr)->setOption(static_cast<QWizard::WizardOption>(option), on != 0);
}

void QWizard_SetOptions(void* ptr, long long options)
{
	static_cast<QWizard*>(ptr)->setOptions(static_cast<QWizard::WizardOption>(options));
}

void QWizard_SetPage(void* ptr, int id, void* page)
{
	static_cast<QWizard*>(ptr)->setPage(id, static_cast<QWizardPage*>(page));
}

void QWizard_SetPixmap(void* ptr, long long which, void* pixmap)
{
	static_cast<QWizard*>(ptr)->setPixmap(static_cast<QWizard::WizardPixmap>(which), *static_cast<QPixmap*>(pixmap));
}

void QWizard_SetSideWidget(void* ptr, void* widget)
{
		static_cast<QWizard*>(ptr)->setSideWidget(static_cast<QWidget*>(widget));
}

void QWizard_SetStartId(void* ptr, int id)
{
	static_cast<QWizard*>(ptr)->setStartId(id);
}

void QWizard_SetSubTitleFormat(void* ptr, long long format)
{
	static_cast<QWizard*>(ptr)->setSubTitleFormat(static_cast<Qt::TextFormat>(format));
}

void QWizard_SetTitleFormat(void* ptr, long long format)
{
	static_cast<QWizard*>(ptr)->setTitleFormat(static_cast<Qt::TextFormat>(format));
}

void QWizard_SetWizardStyle(void* ptr, long long style)
{
	static_cast<QWizard*>(ptr)->setWizardStyle(static_cast<QWizard::WizardStyle>(style));
}

void* QWizard_SideWidget(void* ptr)
{
	return static_cast<QWizard*>(ptr)->sideWidget();
}

int QWizard_StartId(void* ptr)
{
	return static_cast<QWizard*>(ptr)->startId();
}

long long QWizard_SubTitleFormat(void* ptr)
{
	return static_cast<QWizard*>(ptr)->subTitleFormat();
}

char QWizard_TestOption(void* ptr, long long option)
{
	return static_cast<QWizard*>(ptr)->testOption(static_cast<QWizard::WizardOption>(option));
}

long long QWizard_TitleFormat(void* ptr)
{
	return static_cast<QWizard*>(ptr)->titleFormat();
}

char QWizard_ValidateCurrentPage(void* ptr)
{
	return static_cast<QWizard*>(ptr)->validateCurrentPage();
}

char QWizard_ValidateCurrentPageDefault(void* ptr)
{
		return static_cast<QWizard*>(ptr)->QWizard::validateCurrentPage();
}

struct QtWidgets_PackedList QWizard_VisitedPages(void* ptr)
{
	return ({ QList<int>* tmpValue0f21c6 = new QList<int>(static_cast<QWizard*>(ptr)->visitedPages()); QtWidgets_PackedList { tmpValue0f21c6, tmpValue0f21c6->size() }; });
}

long long QWizard_WizardStyle(void* ptr)
{
	return static_cast<QWizard*>(ptr)->wizardStyle();
}

void QWizard_DestroyQWizard(void* ptr)
{
	static_cast<QWizard*>(ptr)->~QWizard();
}

void QWizard_DestroyQWizardDefault(void* ptr)
{
	Q_UNUSED(ptr);

}

int QWizard___pageIds_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

int QWizard___visitedPages_atList(void* ptr, int i)
{
	return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}

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

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

class MyQWizardPage: public QWizardPage
{
public:
	MyQWizardPage(QWidget *parent = Q_NULLPTR) : QWizardPage(parent) {QWizardPage_QWizardPage_QRegisterMetaType();};
	void cleanupPage() { callbackQWizardPage_CleanupPage(this); };
	void Signal_CompleteChanged() { callbackQWizardPage_CompleteChanged(this); };
	void initializePage() { callbackQWizardPage_InitializePage(this); };
	bool isComplete() const { return callbackQWizardPage_IsComplete(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int nextId() const { return callbackQWizardPage_NextId(const_cast<void*>(static_cast<const void*>(this))); };
	bool validatePage() { return callbackQWizardPage_ValidatePage(this) != 0; };
	 ~MyQWizardPage() { callbackQWizardPage_DestroyQWizardPage(this); };
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, event); };
	bool close() { return callbackQWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
	void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, const_cast<QPoint*>(&pos)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
	void hide() { callbackQWidget_Hide(this); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void initPainter(QPainter * painter) const { callbackQWidget_InitPainter(const_cast<void*>(static_cast<const void*>(this)), painter); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<void*>(static_cast<const void*>(this)), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	void lower() { callbackQWidget_Lower(this); };
	int metric(QPaintDevice::PaintDeviceMetric m) const { return callbackQWidget_Metric(const_cast<void*>(static_cast<const void*>(this)), m); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWidget_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void raise() { callbackQWidget_Raise(this); };
	void repaint() { callbackQWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, disable); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	void setStyleSheet(const QString & styleSheet) { QByteArray* t728ae7 = new QByteArray(styleSheet.toUtf8()); QtWidgets_PackedString styleSheetPacked = { const_cast<char*>(t728ae7->prepend("WHITESPACE").constData()+10), t728ae7->size()-10, t728ae7 };callbackQWidget_SetStyleSheet(this, styleSheetPacked); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { QByteArray* tda39a3 = new QByteArray(vqs.toUtf8()); QtWidgets_PackedString vqsPacked = { const_cast<char*>(tda39a3->prepend("WHITESPACE").constData()+10), tda39a3->size()-10, tda39a3 };callbackQWidget_SetWindowTitle(this, vqsPacked); };
	void show() { callbackQWidget_Show(this); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	void showFullScreen() { callbackQWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQWidget_ShowMaximized(this); };
	void showMinimized() { callbackQWidget_ShowMinimized(this); };
	void showNormal() { callbackQWidget_ShowNormal(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
	void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, event); };
	void update() { callbackQWidget_Update(this); };
	void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
	void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, const_cast<QIcon*>(&icon)); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray* t3c6de1 = new QByteArray(title.toUtf8()); QtWidgets_PackedString titlePacked = { const_cast<char*>(t3c6de1->prepend("WHITESPACE").constData()+10), t3c6de1->size()-10, t3c6de1 };callbackQWidget_WindowTitleChanged(this, titlePacked); };
	void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQWidget_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWidget_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtWidgets_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQWidget_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
};

Q_DECLARE_METATYPE(QWizardPage*)
Q_DECLARE_METATYPE(MyQWizardPage*)

int QWizardPage_QWizardPage_QRegisterMetaType(){qRegisterMetaType<QWizardPage*>(); return qRegisterMetaType<MyQWizardPage*>();}

void* QWizardPage_NewQWizardPage(void* parent)
{
		return new MyQWizardPage(static_cast<QWidget*>(parent));
}

struct QtWidgets_PackedString QWizardPage_ButtonText(void* ptr, long long which)
{
	return ({ QByteArray* t060d80 = new QByteArray(static_cast<QWizardPage*>(ptr)->buttonText(static_cast<QWizard::WizardButton>(which)).toUtf8()); QtWidgets_PackedString { const_cast<char*>(t060d80->prepend("WHITESPACE").constData()+10), t060d80->size()-10, t060d80 }; });
}

void QWizardPage_CleanupPage(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->cleanupPage();
}

void QWizardPage_CleanupPageDefault(void* ptr)
{
		static_cast<QWizardPage*>(ptr)->QWizardPage::cleanupPage();
}

void QWizardPage_ConnectCompleteChanged(void* ptr, long long t)
{
	QObject::connect(static_cast<QWizardPage*>(ptr), static_cast<void (QWizardPage::*)()>(&QWizardPage::completeChanged), static_cast<MyQWizardPage*>(ptr), static_cast<void (MyQWizardPage::*)()>(&MyQWizardPage::Signal_CompleteChanged), static_cast<Qt::ConnectionType>(t));
}

void QWizardPage_DisconnectCompleteChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWizardPage*>(ptr), static_cast<void (QWizardPage::*)()>(&QWizardPage::completeChanged), static_cast<MyQWizardPage*>(ptr), static_cast<void (MyQWizardPage::*)()>(&MyQWizardPage::Signal_CompleteChanged));
}

void QWizardPage_CompleteChanged(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->completeChanged();
}

void* QWizardPage_Field(void* ptr, struct QtWidgets_PackedString name)
{
	return new QVariant(static_cast<QWizardPage*>(ptr)->field(QString::fromUtf8(name.data, name.len)));
}

void QWizardPage_InitializePage(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->initializePage();
}

void QWizardPage_InitializePageDefault(void* ptr)
{
		static_cast<QWizardPage*>(ptr)->QWizardPage::initializePage();
}

char QWizardPage_IsCommitPage(void* ptr)
{
	return static_cast<QWizardPage*>(ptr)->isCommitPage();
}

char QWizardPage_IsComplete(void* ptr)
{
	return static_cast<QWizardPage*>(ptr)->isComplete();
}

char QWizardPage_IsCompleteDefault(void* ptr)
{
		return static_cast<QWizardPage*>(ptr)->QWizardPage::isComplete();
}

char QWizardPage_IsFinalPage(void* ptr)
{
	return static_cast<QWizardPage*>(ptr)->isFinalPage();
}

int QWizardPage_NextId(void* ptr)
{
	return static_cast<QWizardPage*>(ptr)->nextId();
}

int QWizardPage_NextIdDefault(void* ptr)
{
		return static_cast<QWizardPage*>(ptr)->QWizardPage::nextId();
}

void* QWizardPage_Pixmap(void* ptr, long long which)
{
	return new QPixmap(static_cast<QWizardPage*>(ptr)->pixmap(static_cast<QWizard::WizardPixmap>(which)));
}

void QWizardPage_RegisterField(void* ptr, struct QtWidgets_PackedString name, void* widget, char* property, char* changedSignal)
{
		static_cast<QWizardPage*>(ptr)->registerField(QString::fromUtf8(name.data, name.len), static_cast<QWidget*>(widget), const_cast<const char*>(property), const_cast<const char*>(changedSignal));
}

void QWizardPage_SetButtonText(void* ptr, long long which, struct QtWidgets_PackedString text)
{
	static_cast<QWizardPage*>(ptr)->setButtonText(static_cast<QWizard::WizardButton>(which), QString::fromUtf8(text.data, text.len));
}

void QWizardPage_SetCommitPage(void* ptr, char commitPage)
{
	static_cast<QWizardPage*>(ptr)->setCommitPage(commitPage != 0);
}

void QWizardPage_SetField(void* ptr, struct QtWidgets_PackedString name, void* value)
{
	static_cast<QWizardPage*>(ptr)->setField(QString::fromUtf8(name.data, name.len), *static_cast<QVariant*>(value));
}

void QWizardPage_SetFinalPage(void* ptr, char finalPage)
{
	static_cast<QWizardPage*>(ptr)->setFinalPage(finalPage != 0);
}

void QWizardPage_SetPixmap(void* ptr, long long which, void* pixmap)
{
	static_cast<QWizardPage*>(ptr)->setPixmap(static_cast<QWizard::WizardPixmap>(which), *static_cast<QPixmap*>(pixmap));
}

void QWizardPage_SetSubTitle(void* ptr, struct QtWidgets_PackedString subTitle)
{
	static_cast<QWizardPage*>(ptr)->setSubTitle(QString::fromUtf8(subTitle.data, subTitle.len));
}

void QWizardPage_SetTitle(void* ptr, struct QtWidgets_PackedString title)
{
	static_cast<QWizardPage*>(ptr)->setTitle(QString::fromUtf8(title.data, title.len));
}

struct QtWidgets_PackedString QWizardPage_SubTitle(void* ptr)
{
	return ({ QByteArray* t00cff1 = new QByteArray(static_cast<QWizardPage*>(ptr)->subTitle().toUtf8()); QtWidgets_PackedString { const_cast<char*>(t00cff1->prepend("WHITESPACE").constData()+10), t00cff1->size()-10, t00cff1 }; });
}

struct QtWidgets_PackedString QWizardPage_Title(void* ptr)
{
	return ({ QByteArray* tf87e47 = new QByteArray(static_cast<QWizardPage*>(ptr)->title().toUtf8()); QtWidgets_PackedString { const_cast<char*>(tf87e47->prepend("WHITESPACE").constData()+10), tf87e47->size()-10, tf87e47 }; });
}

char QWizardPage_ValidatePage(void* ptr)
{
	return static_cast<QWizardPage*>(ptr)->validatePage();
}

char QWizardPage_ValidatePageDefault(void* ptr)
{
		return static_cast<QWizardPage*>(ptr)->QWizardPage::validatePage();
}

void* QWizardPage_Wizard(void* ptr)
{
	return static_cast<QWizardPage*>(ptr)->wizard();
}

void QWizardPage_DestroyQWizardPage(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->~QWizardPage();
}

void QWizardPage_DestroyQWizardPageDefault(void* ptr)
{
	Q_UNUSED(ptr);

}