// +build !minimal

#define protected public
#define private public

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

#include <QAbstractButton>
#include <QAbstractGraphicsShapeItem>
#include <QAbstractItemDelegate>
#include <QAbstractItemModel>
#include <QAbstractItemView>
#include <QAbstractProxyModel>
#include <QAbstractScrollArea>
#include <QAbstractSlider>
#include <QAbstractSpinBox>
#include <QAccessible>
#include <QAccessibleInterface>
#include <QAccessibleWidget>
#include <QAction>
#include <QActionEvent>
#include <QActionGroup>
#include <QApplication>
#include <QBitmap>
#include <QBoxLayout>
#include <QBrush>
#include <QButtonGroup>
#include <QByteArray>
#include <QCalendarWidget>
#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 <QDataWidgetMapper>
#include <QDate>
#include <QDateEdit>
#include <QDateTime>
#include <QDateTimeEdit>
#include <QDesktopWidget>
#include <QDial>
#include <QDialog>
#include <QDialogButtonBox>
#include <QDir>
#include <QDockWidget>
#include <QDoubleSpinBox>
#include <QDrag>
#include <QDragEnterEvent>
#include <QDragLeaveEvent>
#include <QDragMoveEvent>
#include <QDropEvent>
#include <QErrorMessage>
#include <QEvent>
#include <QFile>
#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 <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 <QHeaderView>
#include <QHelpEvent>
#include <QHideEvent>
#include <QIcon>
#include <QInputDialog>
#include <QInputMethod>
#include <QInputMethodEvent>
#include <QItemDelegate>
#include <QItemEditorCreator>
#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 <QList>
#include <QListView>
#include <QListWidget>
#include <QListWidgetItem>
#include <QLocale>
#include <QMacCocoaViewContainer>
#include <QMacNativeWidget>
#include <QMainWindow>
#include <QMargins>
#include <QMatrix4x4>
#include <QMdiArea>
#include <QMdiSubWindow>
#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 <QPagedPaintDevice>
#include <QPaintDevice>
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
#include <QPalette>
#include <QPanGesture>
#include <QPen>
#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 <QRadioButton>
#include <QRect>
#include <QRectF>
#include <QRegExp>
#include <QRegion>
#include <QResizeEvent>
#include <QRubberBand>
#include <QScrollArea>
#include <QScrollBar>
#include <QScroller>
#include <QScrollerProperties>
#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 <QStack>
#include <QStackedLayout>
#include <QStackedWidget>
#include <QState>
#include <QStatusBar>
#include <QString>
#include <QStringList>
#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 <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 <QTextFrame>
#include <QTextOption>
#include <QTileRules>
#include <QTime>
#include <QTimeEdit>
#include <QTimer>
#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) : QAbstractButton(parent) {};
	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 animateClick(int msec) { callbackQAbstractButton_AnimateClick(this, msec); };
	void changeEvent(QEvent * e) { callbackQAbstractButton_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) { callbackQAbstractButton_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQAbstractButton_FocusOutEvent(this, e); };
	bool hitButton(const QPoint & pos) const { return callbackQAbstractButton_HitButton(const_cast<MyQAbstractButton*>(this), const_cast<QPoint*>(&pos)) != 0; };
	void keyPressEvent(QKeyEvent * e) { callbackQAbstractButton_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQAbstractButton_KeyReleaseEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQAbstractButton_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQAbstractButton_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQAbstractButton_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 Signal_Toggled(bool checked) { callbackQAbstractButton_Toggled(this, checked); };
	void actionEvent(QActionEvent * event) { callbackQAbstractButton_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQAbstractButton_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQAbstractButton_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQAbstractButton_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQAbstractButton_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQAbstractButton_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQAbstractButton_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQAbstractButton_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQAbstractButton_MinimumSizeHint(const_cast<MyQAbstractButton*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQAbstractButton_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQAbstractButton_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQAbstractButton_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQAbstractButton_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQAbstractButton_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQAbstractButton_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQAbstractButton_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQAbstractButton_SizeHint(const_cast<MyQAbstractButton*>(this))); };
	bool close() { return callbackQAbstractButton_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQAbstractButton_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQAbstractButton_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQAbstractButton_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQAbstractButton_HasHeightForWidth(const_cast<MyQAbstractButton*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQAbstractButton_HeightForWidth(const_cast<MyQAbstractButton*>(this), w); };
	void hide() { callbackQAbstractButton_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQAbstractButton_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQAbstractButton_InputMethodQuery(const_cast<MyQAbstractButton*>(this), query)); };
	void lower() { callbackQAbstractButton_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQAbstractButton_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQAbstractButton_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQAbstractButton_Raise(this); };
	void repaint() { callbackQAbstractButton_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQAbstractButton_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQAbstractButton_SetDisabled(this, disable); };
	void setFocus() { callbackQAbstractButton_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQAbstractButton_SetHidden(this, hidden); };
	void show() { callbackQAbstractButton_Show(this); };
	void showFullScreen() { callbackQAbstractButton_ShowFullScreen(this); };
	void showMaximized() { callbackQAbstractButton_ShowMaximized(this); };
	void showMinimized() { callbackQAbstractButton_ShowMinimized(this); };
	void showNormal() { callbackQAbstractButton_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQAbstractButton_TabletEvent(this, event); };
	void update() { callbackQAbstractButton_Update(this); };
	void updateMicroFocus() { callbackQAbstractButton_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQAbstractButton_WheelEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQAbstractButton_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractButton_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractButton_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractButton_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractButton_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractButton_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractButton_MetaObject(const_cast<MyQAbstractButton*>(this))); };
};

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_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_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_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(QSize, *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, char* text)
{
	static_cast<QAbstractButton*>(ptr)->setText(QString(text));
}

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

char* QAbstractButton_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QAbstractButton*>(ptr)->text().toUtf8().prepend("WHITESPACE").constData()+10);
}

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

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_ChangeEvent(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QAbstractButton_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::changeEvent(static_cast<QEvent*>(e));
}

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

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

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

void QAbstractButton_ConnectClicked(void* ptr)
{
	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));
}

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);
}

char QAbstractButton_Event(void* ptr, void* e)
{
	return static_cast<QAbstractButton*>(ptr)->event(static_cast<QEvent*>(e));
}

void QAbstractButton_FocusInEvent(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(e));
}

void QAbstractButton_FocusInEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::focusInEvent(static_cast<QFocusEvent*>(e));
}

void QAbstractButton_FocusOutEvent(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QAbstractButton_FocusOutEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::focusOutEvent(static_cast<QFocusEvent*>(e));
}

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)
{
	return static_cast<QAbstractButton*>(ptr)->QAbstractButton::hitButton(*static_cast<QPoint*>(pos));
}

void QAbstractButton_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QAbstractButton_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QAbstractButton_KeyReleaseEvent(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QAbstractButton_KeyReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QAbstractButton_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QAbstractButton_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QAbstractButton_MousePressEvent(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QAbstractButton_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QAbstractButton_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QAbstractButton_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

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

void QAbstractButton_NextCheckStateDefault(void* ptr)
{
	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)
{
	QObject::connect(static_cast<QAbstractButton*>(ptr), static_cast<void (QAbstractButton::*)()>(&QAbstractButton::pressed), static_cast<MyQAbstractButton*>(ptr), static_cast<void (MyQAbstractButton::*)()>(&MyQAbstractButton::Signal_Pressed));
}

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)
{
	QObject::connect(static_cast<QAbstractButton*>(ptr), static_cast<void (QAbstractButton::*)()>(&QAbstractButton::released), static_cast<MyQAbstractButton*>(ptr), static_cast<void (MyQAbstractButton::*)()>(&MyQAbstractButton::Signal_Released));
}

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_TimerEvent(void* ptr, void* e)
{
	static_cast<QAbstractButton*>(ptr)->timerEvent(static_cast<QTimerEvent*>(e));
}

void QAbstractButton_ConnectToggled(void* ptr)
{
	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));
}

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_ActionEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QAbstractButton_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::actionEvent(static_cast<QActionEvent*>(event));
}

void QAbstractButton_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QAbstractButton_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QAbstractButton_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QAbstractButton_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QAbstractButton_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QAbstractButton_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QAbstractButton_DropEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QAbstractButton_DropEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::dropEvent(static_cast<QDropEvent*>(event));
}

void QAbstractButton_EnterEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QAbstractButton_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::enterEvent(static_cast<QEvent*>(event));
}

void QAbstractButton_HideEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QAbstractButton_HideEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::hideEvent(static_cast<QHideEvent*>(event));
}

void QAbstractButton_LeaveEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QAbstractButton_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::leaveEvent(static_cast<QEvent*>(event));
}

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

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

void QAbstractButton_MoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QAbstractButton_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QAbstractButton_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QAbstractButton_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::setStyleSheet(QString(styleSheet));
}

void QAbstractButton_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QAbstractButton_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::setVisible(visible != 0);
}

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

void QAbstractButton_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::setWindowModified(vbo != 0);
}

void QAbstractButton_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QAbstractButton_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::setWindowTitle(QString(vqs));
}

void QAbstractButton_ShowEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QAbstractButton_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::showEvent(static_cast<QShowEvent*>(event));
}

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

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

char QAbstractButton_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QAbstractButton_CloseDefault(void* ptr)
{
	return static_cast<QAbstractButton*>(ptr)->QAbstractButton::close();
}

void QAbstractButton_CloseEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QAbstractButton_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::closeEvent(static_cast<QCloseEvent*>(event));
}

void QAbstractButton_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QAbstractButton_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QAbstractButton_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QAbstractButton*>(ptr)->focusNextPrevChild(next != 0);
}

char QAbstractButton_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QAbstractButton*>(ptr)->QAbstractButton::focusNextPrevChild(next != 0);
}

char QAbstractButton_HasHeightForWidth(void* ptr)
{
	return static_cast<QAbstractButton*>(ptr)->hasHeightForWidth();
}

char QAbstractButton_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QAbstractButton*>(ptr)->QAbstractButton::hasHeightForWidth();
}

int QAbstractButton_HeightForWidth(void* ptr, int w)
{
	return static_cast<QAbstractButton*>(ptr)->heightForWidth(w);
}

int QAbstractButton_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QAbstractButton*>(ptr)->QAbstractButton::heightForWidth(w);
}

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

void QAbstractButton_HideDefault(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::hide();
}

void QAbstractButton_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QAbstractButton_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QAbstractButton_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QAbstractButton*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QAbstractButton_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QAbstractButton*>(ptr)->QAbstractButton::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

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

void QAbstractButton_LowerDefault(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::lower();
}

void QAbstractButton_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractButton_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QAbstractButton_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QAbstractButton*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QAbstractButton_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QAbstractButton*>(ptr)->QAbstractButton::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

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

void QAbstractButton_RaiseDefault(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::raise();
}

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

void QAbstractButton_RepaintDefault(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::repaint();
}

void QAbstractButton_ResizeEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QAbstractButton_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QAbstractButton_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QAbstractButton_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::setDisabled(disable != 0);
}

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

void QAbstractButton_SetFocus2Default(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::setFocus();
}

void QAbstractButton_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QAbstractButton_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::setHidden(hidden != 0);
}

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

void QAbstractButton_ShowDefault(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::show();
}

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

void QAbstractButton_ShowFullScreenDefault(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::showFullScreen();
}

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

void QAbstractButton_ShowMaximizedDefault(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::showMaximized();
}

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

void QAbstractButton_ShowMinimizedDefault(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::showMinimized();
}

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

void QAbstractButton_ShowNormalDefault(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::showNormal();
}

void QAbstractButton_TabletEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QAbstractButton_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::tabletEvent(static_cast<QTabletEvent*>(event));
}

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

void QAbstractButton_UpdateDefault(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::update();
}

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

void QAbstractButton_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::updateMicroFocus();
}

void QAbstractButton_WheelEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QAbstractButton_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QAbstractButton_ChildEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QAbstractButton_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QAbstractButton*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QAbstractButton_CustomEvent(void* ptr, void* event)
{
	static_cast<QAbstractButton*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

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

void QAbstractButton_DeleteLaterDefault(void* ptr)
{
	static_cast<QAbstractButton*>(ptr)->QAbstractButton::deleteLater();
}

void QAbstractButton_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QAbstractButton*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QAbstractButton_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractButton*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QAbstractButton_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractButton*>(ptr)->QAbstractButton::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QAbstractButton_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QAbstractButton*>(ptr)->metaObject());
}

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

class MyQAbstractGraphicsShapeItem: public QAbstractGraphicsShapeItem
{
public:
	MyQAbstractGraphicsShapeItem(QGraphicsItem *parent) : QAbstractGraphicsShapeItem(parent) {};
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQAbstractGraphicsShapeItem_IsObscuredBy(const_cast<MyQAbstractGraphicsShapeItem*>(this), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQAbstractGraphicsShapeItem_OpaqueArea(const_cast<MyQAbstractGraphicsShapeItem*>(this))); };
	void advance(int phase) { callbackQAbstractGraphicsShapeItem_Advance(this, phase); };
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQAbstractGraphicsShapeItem_BoundingRect(const_cast<MyQAbstractGraphicsShapeItem*>(this))); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQAbstractGraphicsShapeItem_CollidesWithItem(const_cast<MyQAbstractGraphicsShapeItem*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQAbstractGraphicsShapeItem_CollidesWithPath(const_cast<MyQAbstractGraphicsShapeItem*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	bool contains(const QPointF & point) const { return callbackQAbstractGraphicsShapeItem_Contains(const_cast<MyQAbstractGraphicsShapeItem*>(this), const_cast<QPointF*>(&point)) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQAbstractGraphicsShapeItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQAbstractGraphicsShapeItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQAbstractGraphicsShapeItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQAbstractGraphicsShapeItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQAbstractGraphicsShapeItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQAbstractGraphicsShapeItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQAbstractGraphicsShapeItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQAbstractGraphicsShapeItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQAbstractGraphicsShapeItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQAbstractGraphicsShapeItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQAbstractGraphicsShapeItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQAbstractGraphicsShapeItem_InputMethodQuery(const_cast<MyQAbstractGraphicsShapeItem*>(this), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQAbstractGraphicsShapeItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQAbstractGraphicsShapeItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQAbstractGraphicsShapeItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQAbstractGraphicsShapeItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQAbstractGraphicsShapeItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQAbstractGraphicsShapeItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQAbstractGraphicsShapeItem_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 callbackQAbstractGraphicsShapeItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQAbstractGraphicsShapeItem_SceneEventFilter(this, watched, event) != 0; };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQAbstractGraphicsShapeItem_Shape(const_cast<MyQAbstractGraphicsShapeItem*>(this))); };
	int type() const { return callbackQAbstractGraphicsShapeItem_Type(const_cast<MyQAbstractGraphicsShapeItem*>(this)); };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQAbstractGraphicsShapeItem_WheelEvent(this, event); };
};

void* QAbstractGraphicsShapeItem_NewQAbstractGraphicsShapeItem(void* parent)
{
	return new MyQAbstractGraphicsShapeItem(static_cast<QGraphicsItem*>(parent));
}

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

char QAbstractGraphicsShapeItem_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QAbstractGraphicsShapeItem_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

void* QAbstractGraphicsShapeItem_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QAbstractGraphicsShapeItem*>(ptr)->opaqueArea());
}

void* QAbstractGraphicsShapeItem_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::opaqueArea());
}

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_Advance(void* ptr, int phase)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->advance(phase);
}

void QAbstractGraphicsShapeItem_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::advance(phase);
}

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



char QAbstractGraphicsShapeItem_CollidesWithItem(void* ptr, void* other, long long mode)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QAbstractGraphicsShapeItem_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QAbstractGraphicsShapeItem_CollidesWithPath(void* ptr, void* path, long long mode)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QAbstractGraphicsShapeItem_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QAbstractGraphicsShapeItem_Contains(void* ptr, void* point)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QAbstractGraphicsShapeItem_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::contains(*static_cast<QPointF*>(point));
}

void QAbstractGraphicsShapeItem_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QAbstractGraphicsShapeItem_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QAbstractGraphicsShapeItem_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QAbstractGraphicsShapeItem_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QAbstractGraphicsShapeItem_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QAbstractGraphicsShapeItem_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QAbstractGraphicsShapeItem_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QAbstractGraphicsShapeItem_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QAbstractGraphicsShapeItem_DropEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QAbstractGraphicsShapeItem_DropEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QAbstractGraphicsShapeItem_FocusInEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractGraphicsShapeItem_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractGraphicsShapeItem_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractGraphicsShapeItem_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractGraphicsShapeItem_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QAbstractGraphicsShapeItem_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QAbstractGraphicsShapeItem_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QAbstractGraphicsShapeItem_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QAbstractGraphicsShapeItem_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QAbstractGraphicsShapeItem_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QAbstractGraphicsShapeItem_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QAbstractGraphicsShapeItem_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QAbstractGraphicsShapeItem_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QAbstractGraphicsShapeItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QAbstractGraphicsShapeItem_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QAbstractGraphicsShapeItem_ItemChange(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QAbstractGraphicsShapeItem*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QAbstractGraphicsShapeItem_ItemChangeDefault(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void QAbstractGraphicsShapeItem_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractGraphicsShapeItem_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractGraphicsShapeItem_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractGraphicsShapeItem_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractGraphicsShapeItem_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QAbstractGraphicsShapeItem_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QAbstractGraphicsShapeItem_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QAbstractGraphicsShapeItem_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QAbstractGraphicsShapeItem_MousePressEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QAbstractGraphicsShapeItem_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QAbstractGraphicsShapeItem_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QAbstractGraphicsShapeItem_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

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));
}



char QAbstractGraphicsShapeItem_SceneEvent(void* ptr, void* event)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QAbstractGraphicsShapeItem_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::sceneEvent(static_cast<QEvent*>(event));
}

char QAbstractGraphicsShapeItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QAbstractGraphicsShapeItem_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

void* QAbstractGraphicsShapeItem_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QAbstractGraphicsShapeItem*>(ptr)->shape());
}

void* QAbstractGraphicsShapeItem_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::shape());
}

int QAbstractGraphicsShapeItem_Type(void* ptr)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->type();
}

int QAbstractGraphicsShapeItem_TypeDefault(void* ptr)
{
	return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::type();
}

void QAbstractGraphicsShapeItem_WheelEvent(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QAbstractGraphicsShapeItem_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

class MyQAbstractItemDelegate: public QAbstractItemDelegate
{
public:
	MyQAbstractItemDelegate(QObject *parent) : QAbstractItemDelegate(parent) {};
	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<MyQAbstractItemDelegate*>(this), parent, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index))); };
	void destroyEditor(QWidget * editor, const QModelIndex & index) const { callbackQAbstractItemDelegate_DestroyEditor(const_cast<MyQAbstractItemDelegate*>(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<MyQAbstractItemDelegate*>(this), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	void setEditorData(QWidget * editor, const QModelIndex & index) const { callbackQAbstractItemDelegate_SetEditorData(const_cast<MyQAbstractItemDelegate*>(this), editor, const_cast<QModelIndex*>(&index)); };
	void setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex & index) const { callbackQAbstractItemDelegate_SetModelData(const_cast<MyQAbstractItemDelegate*>(this), editor, model, const_cast<QModelIndex*>(&index)); };
	QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex & index) const { return *static_cast<QSize*>(callbackQAbstractItemDelegate_SizeHint(const_cast<MyQAbstractItemDelegate*>(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<MyQAbstractItemDelegate*>(this), editor, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	 ~MyQAbstractItemDelegate() { callbackQAbstractItemDelegate_DestroyQAbstractItemDelegate(this); };
	void timerEvent(QTimerEvent * event) { callbackQAbstractItemDelegate_TimerEvent(this, event); };
	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 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<MyQAbstractItemDelegate*>(this))); };
};

void* QAbstractItemDelegate_NewQAbstractItemDelegate(void* parent)
{
	return new MyQAbstractItemDelegate(static_cast<QObject*>(parent));
}

void QAbstractItemDelegate_ConnectCloseEditor(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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));
}

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)
{
	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)
{

}

void QAbstractItemDelegate_TimerEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemDelegate*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QAbstractItemDelegate_ChildEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemDelegate*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QAbstractItemDelegate_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QAbstractItemDelegate*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QAbstractItemDelegate_CustomEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemDelegate*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QAbstractItemDelegate_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemDelegate*>(ptr), "deleteLater");
}

void QAbstractItemDelegate_DeleteLaterDefault(void* ptr)
{
	static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::deleteLater();
}

void QAbstractItemDelegate_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QAbstractItemDelegate*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QAbstractItemDelegate_Event(void* ptr, void* e)
{
	return static_cast<QAbstractItemDelegate*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QAbstractItemDelegate_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractItemDelegate*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QAbstractItemDelegate_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QAbstractItemDelegate_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QAbstractItemDelegate*>(ptr)->metaObject());
}

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

class MyQAbstractItemView: public QAbstractItemView
{
public:
	MyQAbstractItemView(QWidget *parent) : QAbstractItemView(parent) {};
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQAbstractItemView_DragLeaveEvent(this, event); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractItemView_ViewportEvent(this, event) != 0; };
	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 Signal_DoubleClicked(const QModelIndex & index) { callbackQAbstractItemView_DoubleClicked(this, const_cast<QModelIndex*>(&index)); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQAbstractItemView_DragEnterEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQAbstractItemView_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQAbstractItemView_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)); };
	void focusInEvent(QFocusEvent * event) { callbackQAbstractItemView_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQAbstractItemView_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQAbstractItemView_FocusOutEvent(this, event); };
	int horizontalOffset() const { return callbackQAbstractItemView_HorizontalOffset(const_cast<MyQAbstractItemView*>(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<MyQAbstractItemView*>(this), const_cast<QPoint*>(&point))); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQAbstractItemView_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQAbstractItemView_InputMethodQuery(const_cast<MyQAbstractItemView*>(this), query)); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQAbstractItemView_IsIndexHidden(const_cast<MyQAbstractItemView*>(this), const_cast<QModelIndex*>(&index)) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQAbstractItemView_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { callbackQAbstractItemView_KeyboardSearch(this, const_cast<char*>(search.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQAbstractItemView_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQAbstractItemView_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQAbstractItemView_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQAbstractItemView_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) { callbackQAbstractItemView_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); };
	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<MyQAbstractItemView*>(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<MyQAbstractItemView*>(this), column); };
	int sizeHintForRow(int row) const { return callbackQAbstractItemView_SizeHintForRow(const_cast<MyQAbstractItemView*>(this), row); };
	void startDrag(Qt::DropActions supportedActions) { callbackQAbstractItemView_StartDrag(this, supportedActions); };
	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<MyQAbstractItemView*>(this)); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQAbstractItemView_ViewOptions(const_cast<MyQAbstractItemView*>(this))); };
	void Signal_ViewportEntered() { callbackQAbstractItemView_ViewportEntered(this); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractItemView_ViewportSizeHint(const_cast<MyQAbstractItemView*>(this))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQAbstractItemView_VisualRect(const_cast<MyQAbstractItemView*>(this), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQAbstractItemView_VisualRegionForSelection(const_cast<MyQAbstractItemView*>(this), const_cast<QItemSelection*>(&selection))); };
	void paintEvent(QPaintEvent * event) { callbackQAbstractItemView_PaintEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQAbstractItemView_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQAbstractItemView_MinimumSizeHint(const_cast<MyQAbstractItemView*>(this))); };
	void scrollContentsBy(int dx, int dy) { callbackQAbstractItemView_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQAbstractItemView_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQAbstractItemView_SizeHint(const_cast<MyQAbstractItemView*>(this))); };
	void wheelEvent(QWheelEvent * e) { callbackQAbstractItemView_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQAbstractItemView_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQAbstractItemView_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQAbstractItemView_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQAbstractItemView_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQAbstractItemView_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQAbstractItemView_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQAbstractItemView_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQAbstractItemView_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQAbstractItemView_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQAbstractItemView_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQAbstractItemView_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQAbstractItemView_ShowEvent(this, event); };
	bool close() { return callbackQAbstractItemView_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQAbstractItemView_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQAbstractItemView_HasHeightForWidth(const_cast<MyQAbstractItemView*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQAbstractItemView_HeightForWidth(const_cast<MyQAbstractItemView*>(this), w); };
	void hide() { callbackQAbstractItemView_Hide(this); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQAbstractItemView_KeyReleaseEvent(this, event); };
	void lower() { callbackQAbstractItemView_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQAbstractItemView_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQAbstractItemView_Raise(this); };
	void repaint() { callbackQAbstractItemView_Repaint(this); };
	void setDisabled(bool disable) { callbackQAbstractItemView_SetDisabled(this, disable); };
	void setFocus() { callbackQAbstractItemView_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQAbstractItemView_SetHidden(this, hidden); };
	void show() { callbackQAbstractItemView_Show(this); };
	void showFullScreen() { callbackQAbstractItemView_ShowFullScreen(this); };
	void showMaximized() { callbackQAbstractItemView_ShowMaximized(this); };
	void showMinimized() { callbackQAbstractItemView_ShowMinimized(this); };
	void showNormal() { callbackQAbstractItemView_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQAbstractItemView_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQAbstractItemView_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQAbstractItemView_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractItemView_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractItemView_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractItemView_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractItemView_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractItemView_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractItemView_MetaObject(const_cast<MyQAbstractItemView*>(this))); };
};

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

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

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

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();
}

void QAbstractItemView_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QAbstractItemView_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

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

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

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_ResetHorizontalScrollMode(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->resetHorizontalScrollMode();
}

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

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

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

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_SetDefaultDropAction(void* ptr, long long dropAction)
{
	static_cast<QAbstractItemView*>(ptr)->setDefaultDropAction(static_cast<Qt::DropAction>(dropAction));
}

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_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_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();
}

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

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

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

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

char QAbstractItemView_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::viewportEvent(static_cast<QEvent*>(event));
}

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

void QAbstractItemView_ConnectActivated(void* ptr)
{
	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));
}

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));
}

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

void QAbstractItemView_ConnectClicked(void* ptr)
{
	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));
}

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)
{
	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)
{
	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(QModelIndex, *static_cast<QModelIndex*>(current)), Q_ARG(QModelIndex, *static_cast<QModelIndex*>(previous)));
}

void QAbstractItemView_CurrentChangedDefault(void* ptr, void* current, void* previous)
{
	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_DirtyRegionOffset(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QAbstractItemView*>(ptr)->dirtyRegionOffset(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QAbstractItemView_ConnectDoubleClicked(void* ptr)
{
	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));
}

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));
}

void QAbstractItemView_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QAbstractItemView_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QAbstractItemView_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QAbstractItemView_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QAbstractItemView_DropEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QAbstractItemView_DropEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::dropEvent(static_cast<QDropEvent*>(event));
}

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(QModelIndex, *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)
{
	return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

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)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::editorDestroyed(static_cast<QObject*>(editor));
}

void QAbstractItemView_ConnectEntered(void* ptr)
{
	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));
}

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));
}

char QAbstractItemView_Event(void* ptr, void* event)
{
	return static_cast<QAbstractItemView*>(ptr)->event(static_cast<QEvent*>(event));
}

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

void QAbstractItemView_FocusInEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractItemView_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QAbstractItemView_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QAbstractItemView*>(ptr)->focusNextPrevChild(next != 0);
}

char QAbstractItemView_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::focusNextPrevChild(next != 0);
}

void QAbstractItemView_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractItemView_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::focusOutEvent(static_cast<QFocusEvent*>(event));
}

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

void QAbstractItemView_ConnectIconSizeChanged(void* ptr)
{
	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));
}

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));
}

void QAbstractItemView_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QAbstractItemView_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QAbstractItemView_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QAbstractItemView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QAbstractItemView_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

char QAbstractItemView_IsIndexHidden(void* ptr, void* index)
{
	return static_cast<QAbstractItemView*>(ptr)->isIndexHidden(*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_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractItemView_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractItemView_KeyboardSearch(void* ptr, char* search)
{
	static_cast<QAbstractItemView*>(ptr)->keyboardSearch(QString(search));
}

void QAbstractItemView_KeyboardSearchDefault(void* ptr, char* search)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::keyboardSearch(QString(search));
}

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

void QAbstractItemView_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractItemView_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractItemView_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractItemView_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractItemView_MousePressEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractItemView_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractItemView_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractItemView_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

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)
{
	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));
}

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)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::reset();
}

void QAbstractItemView_ResizeEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QAbstractItemView_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::resizeEvent(static_cast<QResizeEvent*>(event));
}

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(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
}

void QAbstractItemView_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end)
{
	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(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
}

void QAbstractItemView_RowsInsertedDefault(void* ptr, void* parent, int start, int end)
{
	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_ScrollToTop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "scrollToTop");
}

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

void QAbstractItemView_SelectAllDefault(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::selectAll();
}

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

void QAbstractItemView_SelectionChangedDefault(void* ptr, void* selected, void* deselected)
{
	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)
{
	return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

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

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

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

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)
{
	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(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QAbstractItemView_SetRootIndexDefault(void* ptr, void* index)
{
	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_SetSelectionModel(void* ptr, void* selectionModel)
{
	static_cast<QAbstractItemView*>(ptr)->setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

void QAbstractItemView_SetSelectionModelDefault(void* ptr, void* selectionModel)
{
	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));
}

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

int QAbstractItemView_SizeHintForColumnDefault(void* ptr, int column)
{
	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)
{
	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)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::startDrag(static_cast<Qt::DropAction>(supportedActions));
}

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

void QAbstractItemView_TimerEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

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

void QAbstractItemView_UpdateGeometriesDefault(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::updateGeometries();
}

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

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

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

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

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_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QAbstractItemView*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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

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_PaintEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QAbstractItemView_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::paintEvent(static_cast<QPaintEvent*>(event));
}

void QAbstractItemView_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QAbstractItemView*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QAbstractItemView_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

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

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

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

void QAbstractItemView_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::scrollContentsBy(dx, dy);
}

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

void QAbstractItemView_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setupViewport(static_cast<QWidget*>(viewport));
}

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

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

void QAbstractItemView_WheelEvent(void* ptr, void* e)
{
	static_cast<QAbstractItemView*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QAbstractItemView_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QAbstractItemView_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QAbstractItemView*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QAbstractItemView_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::changeEvent(static_cast<QEvent*>(ev));
}

void QAbstractItemView_ActionEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QAbstractItemView_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::actionEvent(static_cast<QActionEvent*>(event));
}

void QAbstractItemView_EnterEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QAbstractItemView_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::enterEvent(static_cast<QEvent*>(event));
}

void QAbstractItemView_HideEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QAbstractItemView_HideEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::hideEvent(static_cast<QHideEvent*>(event));
}

void QAbstractItemView_LeaveEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QAbstractItemView_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::leaveEvent(static_cast<QEvent*>(event));
}

void QAbstractItemView_MoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QAbstractItemView_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QAbstractItemView_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QAbstractItemView_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setStyleSheet(QString(styleSheet));
}

void QAbstractItemView_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QAbstractItemView_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setVisible(visible != 0);
}

void QAbstractItemView_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QAbstractItemView_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setWindowModified(vbo != 0);
}

void QAbstractItemView_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QAbstractItemView_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setWindowTitle(QString(vqs));
}

void QAbstractItemView_ShowEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QAbstractItemView_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::showEvent(static_cast<QShowEvent*>(event));
}

char QAbstractItemView_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QAbstractItemView_CloseDefault(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::close();
}

void QAbstractItemView_CloseEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QAbstractItemView_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::closeEvent(static_cast<QCloseEvent*>(event));
}

char QAbstractItemView_HasHeightForWidth(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->hasHeightForWidth();
}

char QAbstractItemView_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::hasHeightForWidth();
}

int QAbstractItemView_HeightForWidth(void* ptr, int w)
{
	return static_cast<QAbstractItemView*>(ptr)->heightForWidth(w);
}

int QAbstractItemView_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::heightForWidth(w);
}

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

void QAbstractItemView_HideDefault(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::hide();
}

void QAbstractItemView_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractItemView_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

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

void QAbstractItemView_LowerDefault(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::lower();
}

char QAbstractItemView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QAbstractItemView*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QAbstractItemView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

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

void QAbstractItemView_RaiseDefault(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::raise();
}

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

void QAbstractItemView_RepaintDefault(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::repaint();
}

void QAbstractItemView_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QAbstractItemView_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setDisabled(disable != 0);
}

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

void QAbstractItemView_SetFocus2Default(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setFocus();
}

void QAbstractItemView_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QAbstractItemView_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setHidden(hidden != 0);
}

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

void QAbstractItemView_ShowDefault(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::show();
}

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

void QAbstractItemView_ShowFullScreenDefault(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::showFullScreen();
}

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

void QAbstractItemView_ShowMaximizedDefault(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::showMaximized();
}

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

void QAbstractItemView_ShowMinimizedDefault(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::showMinimized();
}

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

void QAbstractItemView_ShowNormalDefault(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::showNormal();
}

void QAbstractItemView_TabletEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QAbstractItemView_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::tabletEvent(static_cast<QTabletEvent*>(event));
}

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

void QAbstractItemView_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::updateMicroFocus();
}

void QAbstractItemView_ChildEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QAbstractItemView_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QAbstractItemView*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QAbstractItemView_CustomEvent(void* ptr, void* event)
{
	static_cast<QAbstractItemView*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

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

void QAbstractItemView_DeleteLaterDefault(void* ptr)
{
	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::deleteLater();
}

void QAbstractItemView_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QAbstractItemView*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QAbstractItemView_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractItemView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QAbstractItemView_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QAbstractItemView_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QAbstractItemView*>(ptr)->metaObject());
}

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

class MyQAbstractScrollArea: public QAbstractScrollArea
{
public:
	MyQAbstractScrollArea(QWidget *parent) : QAbstractScrollArea(parent) {};
	void dragEnterEvent(QDragEnterEvent * event) { callbackQAbstractScrollArea_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQAbstractScrollArea_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQAbstractScrollArea_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQAbstractScrollArea_DropEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQAbstractScrollArea_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQAbstractScrollArea_ResizeEvent(this, event); };
	bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, event) != 0; };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQAbstractScrollArea_ContextMenuEvent(this, e); };
	void keyPressEvent(QKeyEvent * e) { callbackQAbstractScrollArea_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_MinimumSizeHint(const_cast<MyQAbstractScrollArea*>(this))); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQAbstractScrollArea_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQAbstractScrollArea_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQAbstractScrollArea_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQAbstractScrollArea_MouseReleaseEvent(this, e); };
	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*>(callbackQAbstractScrollArea_SizeHint(const_cast<MyQAbstractScrollArea*>(this))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<MyQAbstractScrollArea*>(this))); };
	void wheelEvent(QWheelEvent * e) { callbackQAbstractScrollArea_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQAbstractScrollArea_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQAbstractScrollArea_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQAbstractScrollArea_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQAbstractScrollArea_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQAbstractScrollArea_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQAbstractScrollArea_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQAbstractScrollArea_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQAbstractScrollArea_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQAbstractScrollArea_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQAbstractScrollArea_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQAbstractScrollArea_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQAbstractScrollArea_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQAbstractScrollArea_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQAbstractScrollArea_ShowEvent(this, event); };
	bool close() { return callbackQAbstractScrollArea_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQAbstractScrollArea_CloseEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQAbstractScrollArea_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQAbstractScrollArea_HasHeightForWidth(const_cast<MyQAbstractScrollArea*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQAbstractScrollArea_HeightForWidth(const_cast<MyQAbstractScrollArea*>(this), w); };
	void hide() { callbackQAbstractScrollArea_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQAbstractScrollArea_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQAbstractScrollArea_InputMethodQuery(const_cast<MyQAbstractScrollArea*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQAbstractScrollArea_KeyReleaseEvent(this, event); };
	void lower() { callbackQAbstractScrollArea_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQAbstractScrollArea_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQAbstractScrollArea_Raise(this); };
	void repaint() { callbackQAbstractScrollArea_Repaint(this); };
	void setDisabled(bool disable) { callbackQAbstractScrollArea_SetDisabled(this, disable); };
	void setFocus() { callbackQAbstractScrollArea_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQAbstractScrollArea_SetHidden(this, hidden); };
	void show() { callbackQAbstractScrollArea_Show(this); };
	void showFullScreen() { callbackQAbstractScrollArea_ShowFullScreen(this); };
	void showMaximized() { callbackQAbstractScrollArea_ShowMaximized(this); };
	void showMinimized() { callbackQAbstractScrollArea_ShowMinimized(this); };
	void showNormal() { callbackQAbstractScrollArea_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQAbstractScrollArea_TabletEvent(this, event); };
	void update() { callbackQAbstractScrollArea_Update(this); };
	void updateMicroFocus() { callbackQAbstractScrollArea_UpdateMicroFocus(this); };
	void timerEvent(QTimerEvent * event) { callbackQAbstractScrollArea_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQAbstractScrollArea_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractScrollArea_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractScrollArea_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractScrollArea_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractScrollArea_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractScrollArea_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractScrollArea_MetaObject(const_cast<MyQAbstractScrollArea*>(this))); };
};

void QAbstractScrollArea_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QAbstractScrollArea_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QAbstractScrollArea_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QAbstractScrollArea_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QAbstractScrollArea_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QAbstractScrollArea_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QAbstractScrollArea_DropEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QAbstractScrollArea_DropEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::dropEvent(static_cast<QDropEvent*>(event));
}

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

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

void QAbstractScrollArea_PaintEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QAbstractScrollArea_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::paintEvent(static_cast<QPaintEvent*>(event));
}

void QAbstractScrollArea_ResizeEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QAbstractScrollArea_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::resizeEvent(static_cast<QResizeEvent*>(event));
}

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_SetVerticalScrollBarPolicy(void* ptr, long long vqt)
{
	static_cast<QAbstractScrollArea*>(ptr)->setVerticalScrollBarPolicy(static_cast<Qt::ScrollBarPolicy>(vqt));
}

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

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

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

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

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_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QAbstractScrollArea_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

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

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

void QAbstractScrollArea_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QAbstractScrollArea_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::keyPressEvent(static_cast<QKeyEvent*>(e));
}

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

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

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

void QAbstractScrollArea_MouseDoubleClickEvent(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QAbstractScrollArea_MouseDoubleClickEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QAbstractScrollArea_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QAbstractScrollArea_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QAbstractScrollArea_MousePressEvent(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QAbstractScrollArea_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QAbstractScrollArea_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QAbstractScrollArea_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

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)
{
	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_SetVerticalScrollBar(void* ptr, void* scrollBar)
{
	static_cast<QAbstractScrollArea*>(ptr)->setVerticalScrollBar(static_cast<QScrollBar*>(scrollBar));
}

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

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

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

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

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

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

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

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

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

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)
{
	return ({ QSize tmpValue = static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QAbstractScrollArea_WheelEvent(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QAbstractScrollArea_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::wheelEvent(static_cast<QWheelEvent*>(e));
}

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

void QAbstractScrollArea_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QAbstractScrollArea*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QAbstractScrollArea_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::changeEvent(static_cast<QEvent*>(ev));
}

void QAbstractScrollArea_ActionEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QAbstractScrollArea_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::actionEvent(static_cast<QActionEvent*>(event));
}

void QAbstractScrollArea_EnterEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QAbstractScrollArea_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::enterEvent(static_cast<QEvent*>(event));
}

void QAbstractScrollArea_FocusInEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractScrollArea_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractScrollArea_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractScrollArea_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractScrollArea_HideEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QAbstractScrollArea_HideEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::hideEvent(static_cast<QHideEvent*>(event));
}

void QAbstractScrollArea_LeaveEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QAbstractScrollArea_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::leaveEvent(static_cast<QEvent*>(event));
}

void QAbstractScrollArea_MoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QAbstractScrollArea_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QAbstractScrollArea_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QAbstractScrollArea_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setStyleSheet(QString(styleSheet));
}

void QAbstractScrollArea_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QAbstractScrollArea_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setVisible(visible != 0);
}

void QAbstractScrollArea_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QAbstractScrollArea_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setWindowModified(vbo != 0);
}

void QAbstractScrollArea_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QAbstractScrollArea_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setWindowTitle(QString(vqs));
}

void QAbstractScrollArea_ShowEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QAbstractScrollArea_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::showEvent(static_cast<QShowEvent*>(event));
}

char QAbstractScrollArea_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QAbstractScrollArea_CloseDefault(void* ptr)
{
	return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::close();
}

void QAbstractScrollArea_CloseEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QAbstractScrollArea_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::closeEvent(static_cast<QCloseEvent*>(event));
}

char QAbstractScrollArea_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QAbstractScrollArea*>(ptr)->focusNextPrevChild(next != 0);
}

char QAbstractScrollArea_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::focusNextPrevChild(next != 0);
}

char QAbstractScrollArea_HasHeightForWidth(void* ptr)
{
	return static_cast<QAbstractScrollArea*>(ptr)->hasHeightForWidth();
}

char QAbstractScrollArea_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::hasHeightForWidth();
}

int QAbstractScrollArea_HeightForWidth(void* ptr, int w)
{
	return static_cast<QAbstractScrollArea*>(ptr)->heightForWidth(w);
}

int QAbstractScrollArea_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::heightForWidth(w);
}

void QAbstractScrollArea_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "hide");
}

void QAbstractScrollArea_HideDefault(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::hide();
}

void QAbstractScrollArea_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QAbstractScrollArea_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QAbstractScrollArea_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QAbstractScrollArea*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QAbstractScrollArea_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QAbstractScrollArea_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractScrollArea_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractScrollArea_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "lower");
}

void QAbstractScrollArea_LowerDefault(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::lower();
}

char QAbstractScrollArea_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QAbstractScrollArea*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QAbstractScrollArea_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QAbstractScrollArea_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "raise");
}

void QAbstractScrollArea_RaiseDefault(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::raise();
}

void QAbstractScrollArea_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "repaint");
}

void QAbstractScrollArea_RepaintDefault(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::repaint();
}

void QAbstractScrollArea_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QAbstractScrollArea_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setDisabled(disable != 0);
}

void QAbstractScrollArea_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "setFocus");
}

void QAbstractScrollArea_SetFocus2Default(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setFocus();
}

void QAbstractScrollArea_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QAbstractScrollArea_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setHidden(hidden != 0);
}

void QAbstractScrollArea_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "show");
}

void QAbstractScrollArea_ShowDefault(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::show();
}

void QAbstractScrollArea_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "showFullScreen");
}

void QAbstractScrollArea_ShowFullScreenDefault(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::showFullScreen();
}

void QAbstractScrollArea_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "showMaximized");
}

void QAbstractScrollArea_ShowMaximizedDefault(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::showMaximized();
}

void QAbstractScrollArea_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "showMinimized");
}

void QAbstractScrollArea_ShowMinimizedDefault(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::showMinimized();
}

void QAbstractScrollArea_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "showNormal");
}

void QAbstractScrollArea_ShowNormalDefault(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::showNormal();
}

void QAbstractScrollArea_TabletEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QAbstractScrollArea_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QAbstractScrollArea_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "update");
}

void QAbstractScrollArea_UpdateDefault(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::update();
}

void QAbstractScrollArea_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "updateMicroFocus");
}

void QAbstractScrollArea_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::updateMicroFocus();
}

void QAbstractScrollArea_TimerEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QAbstractScrollArea_ChildEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QAbstractScrollArea_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QAbstractScrollArea*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QAbstractScrollArea_CustomEvent(void* ptr, void* event)
{
	static_cast<QAbstractScrollArea*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QAbstractScrollArea_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "deleteLater");
}

void QAbstractScrollArea_DeleteLaterDefault(void* ptr)
{
	static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::deleteLater();
}

void QAbstractScrollArea_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QAbstractScrollArea*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QAbstractScrollArea_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractScrollArea*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QAbstractScrollArea_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QAbstractScrollArea_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QAbstractScrollArea*>(ptr)->metaObject());
}

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

class MyQAbstractSlider: public QAbstractSlider
{
public:
	MyQAbstractSlider(QWidget *parent) : QAbstractSlider(parent) {};
	void setOrientation(Qt::Orientation vqt) { callbackQAbstractSlider_SetOrientation(this, vqt); };
	void setValue(int vin) { callbackQAbstractSlider_SetValue(this, vin); };
	void Signal_ActionTriggered(int action) { callbackQAbstractSlider_ActionTriggered(this, action); };
	void changeEvent(QEvent * ev) { callbackQAbstractSlider_ChangeEvent(this, ev); };
	void keyPressEvent(QKeyEvent * ev) { callbackQAbstractSlider_KeyPressEvent(this, ev); };
	void Signal_RangeChanged(int min, int max) { callbackQAbstractSlider_RangeChanged(this, min, max); };
	void setRange(int min, int max) { callbackQAbstractSlider_SetRange(this, min, max); };
	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 Signal_ValueChanged(int value) { callbackQAbstractSlider_ValueChanged(this, value); };
	void wheelEvent(QWheelEvent * e) { callbackQAbstractSlider_WheelEvent(this, e); };
	void actionEvent(QActionEvent * event) { callbackQAbstractSlider_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQAbstractSlider_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQAbstractSlider_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQAbstractSlider_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQAbstractSlider_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQAbstractSlider_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQAbstractSlider_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQAbstractSlider_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQAbstractSlider_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQAbstractSlider_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQAbstractSlider_MinimumSizeHint(const_cast<MyQAbstractSlider*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQAbstractSlider_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQAbstractSlider_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQAbstractSlider_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQAbstractSlider_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQAbstractSlider_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQAbstractSlider_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQAbstractSlider_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQAbstractSlider_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQAbstractSlider_SizeHint(const_cast<MyQAbstractSlider*>(this))); };
	bool close() { return callbackQAbstractSlider_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQAbstractSlider_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQAbstractSlider_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQAbstractSlider_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQAbstractSlider_HasHeightForWidth(const_cast<MyQAbstractSlider*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQAbstractSlider_HeightForWidth(const_cast<MyQAbstractSlider*>(this), w); };
	void hide() { callbackQAbstractSlider_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQAbstractSlider_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQAbstractSlider_InputMethodQuery(const_cast<MyQAbstractSlider*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQAbstractSlider_KeyReleaseEvent(this, event); };
	void lower() { callbackQAbstractSlider_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQAbstractSlider_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQAbstractSlider_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQAbstractSlider_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQAbstractSlider_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQAbstractSlider_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQAbstractSlider_Raise(this); };
	void repaint() { callbackQAbstractSlider_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQAbstractSlider_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQAbstractSlider_SetDisabled(this, disable); };
	void setFocus() { callbackQAbstractSlider_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQAbstractSlider_SetHidden(this, hidden); };
	void show() { callbackQAbstractSlider_Show(this); };
	void showFullScreen() { callbackQAbstractSlider_ShowFullScreen(this); };
	void showMaximized() { callbackQAbstractSlider_ShowMaximized(this); };
	void showMinimized() { callbackQAbstractSlider_ShowMinimized(this); };
	void showNormal() { callbackQAbstractSlider_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQAbstractSlider_TabletEvent(this, event); };
	void update() { callbackQAbstractSlider_Update(this); };
	void updateMicroFocus() { callbackQAbstractSlider_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQAbstractSlider_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractSlider_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractSlider_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractSlider_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractSlider_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractSlider_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractSlider_MetaObject(const_cast<MyQAbstractSlider*>(this))); };
};

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_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)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setOrientation", Q_ARG(Qt::Orientation, static_cast<Qt::Orientation>(vqt)));
}

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

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));
}

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

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

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

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

void QAbstractSlider_ConnectActionTriggered(void* ptr)
{
	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));
}

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);
}

void QAbstractSlider_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QAbstractSlider*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QAbstractSlider_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::changeEvent(static_cast<QEvent*>(ev));
}

char QAbstractSlider_Event(void* ptr, void* e)
{
	return static_cast<QAbstractSlider*>(ptr)->event(static_cast<QEvent*>(e));
}

void QAbstractSlider_KeyPressEvent(void* ptr, void* ev)
{
	static_cast<QAbstractSlider*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(ev));
}

void QAbstractSlider_KeyPressEventDefault(void* ptr, void* ev)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::keyPressEvent(static_cast<QKeyEvent*>(ev));
}

void QAbstractSlider_ConnectRangeChanged(void* ptr)
{
	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));
}

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_SetRange(void* ptr, int min, int max)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setRange", Q_ARG(int, min), Q_ARG(int, 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_SliderChange(void* ptr, long long change)
{
	static_cast<QAbstractSlider*>(ptr)->sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
}

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

void QAbstractSlider_ConnectSliderMoved(void* ptr)
{
	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));
}

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);
}

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

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)
{
	QObject::connect(static_cast<QAbstractSlider*>(ptr), static_cast<void (QAbstractSlider::*)()>(&QAbstractSlider::sliderReleased), static_cast<MyQAbstractSlider*>(ptr), static_cast<void (MyQAbstractSlider::*)()>(&MyQAbstractSlider::Signal_SliderReleased));
}

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_TimerEvent(void* ptr, void* e)
{
	static_cast<QAbstractSlider*>(ptr)->timerEvent(static_cast<QTimerEvent*>(e));
}

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

void QAbstractSlider_ConnectValueChanged(void* ptr)
{
	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));
}

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_WheelEvent(void* ptr, void* e)
{
	static_cast<QAbstractSlider*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QAbstractSlider_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::wheelEvent(static_cast<QWheelEvent*>(e));
}

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

void QAbstractSlider_ActionEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QAbstractSlider_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::actionEvent(static_cast<QActionEvent*>(event));
}

void QAbstractSlider_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QAbstractSlider_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QAbstractSlider_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QAbstractSlider_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QAbstractSlider_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QAbstractSlider_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QAbstractSlider_DropEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QAbstractSlider_DropEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::dropEvent(static_cast<QDropEvent*>(event));
}

void QAbstractSlider_EnterEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QAbstractSlider_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::enterEvent(static_cast<QEvent*>(event));
}

void QAbstractSlider_FocusInEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractSlider_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractSlider_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractSlider_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractSlider_HideEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QAbstractSlider_HideEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::hideEvent(static_cast<QHideEvent*>(event));
}

void QAbstractSlider_LeaveEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QAbstractSlider_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::leaveEvent(static_cast<QEvent*>(event));
}

void* QAbstractSlider_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QAbstractSlider*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QAbstractSlider_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QAbstractSlider_MoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QAbstractSlider_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::moveEvent(static_cast<QMoveEvent*>(event));
}

void QAbstractSlider_PaintEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QAbstractSlider_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::paintEvent(static_cast<QPaintEvent*>(event));
}

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

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

void QAbstractSlider_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QAbstractSlider_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setStyleSheet(QString(styleSheet));
}

void QAbstractSlider_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QAbstractSlider_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setVisible(visible != 0);
}

void QAbstractSlider_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QAbstractSlider_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setWindowModified(vbo != 0);
}

void QAbstractSlider_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QAbstractSlider_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setWindowTitle(QString(vqs));
}

void QAbstractSlider_ShowEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QAbstractSlider_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::showEvent(static_cast<QShowEvent*>(event));
}

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

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

char QAbstractSlider_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QAbstractSlider_CloseDefault(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::close();
}

void QAbstractSlider_CloseEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QAbstractSlider_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::closeEvent(static_cast<QCloseEvent*>(event));
}

void QAbstractSlider_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QAbstractSlider_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QAbstractSlider_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QAbstractSlider*>(ptr)->focusNextPrevChild(next != 0);
}

char QAbstractSlider_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::focusNextPrevChild(next != 0);
}

char QAbstractSlider_HasHeightForWidth(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->hasHeightForWidth();
}

char QAbstractSlider_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::hasHeightForWidth();
}

int QAbstractSlider_HeightForWidth(void* ptr, int w)
{
	return static_cast<QAbstractSlider*>(ptr)->heightForWidth(w);
}

int QAbstractSlider_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::heightForWidth(w);
}

void QAbstractSlider_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "hide");
}

void QAbstractSlider_HideDefault(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::hide();
}

void QAbstractSlider_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QAbstractSlider_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QAbstractSlider_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QAbstractSlider*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QAbstractSlider_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QAbstractSlider_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractSlider_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractSlider_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "lower");
}

void QAbstractSlider_LowerDefault(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::lower();
}

void QAbstractSlider_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSlider_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSlider_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSlider_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSlider_MousePressEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSlider_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSlider_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSlider_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QAbstractSlider_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QAbstractSlider*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QAbstractSlider_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QAbstractSlider_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "raise");
}

void QAbstractSlider_RaiseDefault(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::raise();
}

void QAbstractSlider_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "repaint");
}

void QAbstractSlider_RepaintDefault(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::repaint();
}

void QAbstractSlider_ResizeEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QAbstractSlider_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QAbstractSlider_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QAbstractSlider_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setDisabled(disable != 0);
}

void QAbstractSlider_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setFocus");
}

void QAbstractSlider_SetFocus2Default(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setFocus();
}

void QAbstractSlider_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QAbstractSlider_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setHidden(hidden != 0);
}

void QAbstractSlider_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "show");
}

void QAbstractSlider_ShowDefault(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::show();
}

void QAbstractSlider_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "showFullScreen");
}

void QAbstractSlider_ShowFullScreenDefault(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::showFullScreen();
}

void QAbstractSlider_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "showMaximized");
}

void QAbstractSlider_ShowMaximizedDefault(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::showMaximized();
}

void QAbstractSlider_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "showMinimized");
}

void QAbstractSlider_ShowMinimizedDefault(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::showMinimized();
}

void QAbstractSlider_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "showNormal");
}

void QAbstractSlider_ShowNormalDefault(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::showNormal();
}

void QAbstractSlider_TabletEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QAbstractSlider_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QAbstractSlider_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "update");
}

void QAbstractSlider_UpdateDefault(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::update();
}

void QAbstractSlider_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "updateMicroFocus");
}

void QAbstractSlider_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::updateMicroFocus();
}

void QAbstractSlider_ChildEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QAbstractSlider_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QAbstractSlider*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QAbstractSlider_CustomEvent(void* ptr, void* event)
{
	static_cast<QAbstractSlider*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QAbstractSlider_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "deleteLater");
}

void QAbstractSlider_DeleteLaterDefault(void* ptr)
{
	static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::deleteLater();
}

void QAbstractSlider_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QAbstractSlider*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QAbstractSlider_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractSlider*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QAbstractSlider_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QAbstractSlider_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QAbstractSlider*>(ptr)->metaObject());
}

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

class MyQAbstractSpinBox: public QAbstractSpinBox
{
public:
	MyQAbstractSpinBox(QWidget *parent) : QAbstractSpinBox(parent) {};
	void changeEvent(QEvent * event) { callbackQAbstractSpinBox_ChangeEvent(this, event); };
	void clear() { callbackQAbstractSpinBox_Clear(this); };
	void closeEvent(QCloseEvent * event) { callbackQAbstractSpinBox_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQAbstractSpinBox_ContextMenuEvent(this, event); };
	void Signal_EditingFinished() { callbackQAbstractSpinBox_EditingFinished(this); };
	void fixup(QString & input) const { callbackQAbstractSpinBox_Fixup(const_cast<MyQAbstractSpinBox*>(this), const_cast<char*>(input.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void focusInEvent(QFocusEvent * event) { callbackQAbstractSpinBox_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQAbstractSpinBox_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQAbstractSpinBox_HideEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQAbstractSpinBox_InputMethodQuery(const_cast<MyQAbstractSpinBox*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQAbstractSpinBox_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQAbstractSpinBox_KeyReleaseEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQAbstractSpinBox_MinimumSizeHint(const_cast<MyQAbstractSpinBox*>(this))); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQAbstractSpinBox_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQAbstractSpinBox_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQAbstractSpinBox_MouseReleaseEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQAbstractSpinBox_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQAbstractSpinBox_ResizeEvent(this, event); };
	void selectAll() { callbackQAbstractSpinBox_SelectAll(this); };
	void showEvent(QShowEvent * event) { callbackQAbstractSpinBox_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQAbstractSpinBox_SizeHint(const_cast<MyQAbstractSpinBox*>(this))); };
	void stepBy(int steps) { callbackQAbstractSpinBox_StepBy(this, steps); };
	void stepDown() { callbackQAbstractSpinBox_StepDown(this); };
	StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQAbstractSpinBox_StepEnabled(const_cast<MyQAbstractSpinBox*>(this))); };
	void stepUp() { callbackQAbstractSpinBox_StepUp(this); };
	QValidator::State validate(QString & input, int & pos) const { return static_cast<QValidator::State>(callbackQAbstractSpinBox_Validate(const_cast<MyQAbstractSpinBox*>(this), const_cast<char*>(input.toUtf8().prepend("WHITESPACE").constData()+10), pos)); };
	void wheelEvent(QWheelEvent * event) { callbackQAbstractSpinBox_WheelEvent(this, event); };
	void actionEvent(QActionEvent * event) { callbackQAbstractSpinBox_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQAbstractSpinBox_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQAbstractSpinBox_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQAbstractSpinBox_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQAbstractSpinBox_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQAbstractSpinBox_EnterEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQAbstractSpinBox_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQAbstractSpinBox_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQAbstractSpinBox_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQAbstractSpinBox_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQAbstractSpinBox_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQAbstractSpinBox_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQAbstractSpinBox_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQAbstractSpinBox_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQAbstractSpinBox_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQAbstractSpinBox_HasHeightForWidth(const_cast<MyQAbstractSpinBox*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQAbstractSpinBox_HeightForWidth(const_cast<MyQAbstractSpinBox*>(this), w); };
	void hide() { callbackQAbstractSpinBox_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQAbstractSpinBox_InputMethodEvent(this, event); };
	void lower() { callbackQAbstractSpinBox_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQAbstractSpinBox_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQAbstractSpinBox_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQAbstractSpinBox_Raise(this); };
	void repaint() { callbackQAbstractSpinBox_Repaint(this); };
	void setDisabled(bool disable) { callbackQAbstractSpinBox_SetDisabled(this, disable); };
	void setFocus() { callbackQAbstractSpinBox_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQAbstractSpinBox_SetHidden(this, hidden); };
	void show() { callbackQAbstractSpinBox_Show(this); };
	void showFullScreen() { callbackQAbstractSpinBox_ShowFullScreen(this); };
	void showMaximized() { callbackQAbstractSpinBox_ShowMaximized(this); };
	void showMinimized() { callbackQAbstractSpinBox_ShowMinimized(this); };
	void showNormal() { callbackQAbstractSpinBox_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQAbstractSpinBox_TabletEvent(this, event); };
	void update() { callbackQAbstractSpinBox_Update(this); };
	void updateMicroFocus() { callbackQAbstractSpinBox_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQAbstractSpinBox_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractSpinBox_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractSpinBox_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractSpinBox_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractSpinBox_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractSpinBox_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractSpinBox_MetaObject(const_cast<MyQAbstractSpinBox*>(this))); };
};

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

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

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

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

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

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_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, char* txt)
{
	static_cast<QAbstractSpinBox*>(ptr)->setSpecialValueText(QString(txt));
}

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

char* QAbstractSpinBox_SpecialValueText(void* ptr)
{
	return const_cast<char*>(static_cast<QAbstractSpinBox*>(ptr)->specialValueText().toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QAbstractSpinBox_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QAbstractSpinBox*>(ptr)->text().toUtf8().prepend("WHITESPACE").constData()+10);
}

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

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

void QAbstractSpinBox_ChangeEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QAbstractSpinBox_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::changeEvent(static_cast<QEvent*>(event));
}

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

void QAbstractSpinBox_ClearDefault(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::clear();
}

void QAbstractSpinBox_CloseEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QAbstractSpinBox_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::closeEvent(static_cast<QCloseEvent*>(event));
}

void QAbstractSpinBox_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QAbstractSpinBox_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

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

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();
}

char QAbstractSpinBox_Event(void* ptr, void* event)
{
	return static_cast<QAbstractSpinBox*>(ptr)->event(static_cast<QEvent*>(event));
}

void QAbstractSpinBox_Fixup(void* ptr, char* input)
{
	static_cast<QAbstractSpinBox*>(ptr)->fixup(*(new QString(input)));
}

void QAbstractSpinBox_FixupDefault(void* ptr, char* input)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::fixup(*(new QString(input)));
}

void QAbstractSpinBox_FocusInEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractSpinBox_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractSpinBox_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractSpinBox_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QAbstractSpinBox_HideEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QAbstractSpinBox_HideEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::hideEvent(static_cast<QHideEvent*>(event));
}

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

void* QAbstractSpinBox_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QAbstractSpinBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QAbstractSpinBox_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

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

void QAbstractSpinBox_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractSpinBox_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractSpinBox_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QAbstractSpinBox_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

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

void* QAbstractSpinBox_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QAbstractSpinBox*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QAbstractSpinBox_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QAbstractSpinBox_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSpinBox_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSpinBox_MousePressEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSpinBox_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSpinBox_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSpinBox_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSpinBox_PaintEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QAbstractSpinBox_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::paintEvent(static_cast<QPaintEvent*>(event));
}

void QAbstractSpinBox_ResizeEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QAbstractSpinBox_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::resizeEvent(static_cast<QResizeEvent*>(event));
}

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

void QAbstractSpinBox_ShowEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QAbstractSpinBox_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::showEvent(static_cast<QShowEvent*>(event));
}

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

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

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

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

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

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

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

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

void QAbstractSpinBox_TimerEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

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

void QAbstractSpinBox_WheelEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QAbstractSpinBox_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::wheelEvent(static_cast<QWheelEvent*>(event));
}

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

void QAbstractSpinBox_ActionEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QAbstractSpinBox_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::actionEvent(static_cast<QActionEvent*>(event));
}

void QAbstractSpinBox_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QAbstractSpinBox_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QAbstractSpinBox_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QAbstractSpinBox_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QAbstractSpinBox_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QAbstractSpinBox_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QAbstractSpinBox_DropEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QAbstractSpinBox_DropEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::dropEvent(static_cast<QDropEvent*>(event));
}

void QAbstractSpinBox_EnterEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QAbstractSpinBox_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::enterEvent(static_cast<QEvent*>(event));
}

void QAbstractSpinBox_LeaveEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QAbstractSpinBox_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::leaveEvent(static_cast<QEvent*>(event));
}

void QAbstractSpinBox_MoveEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QAbstractSpinBox_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QAbstractSpinBox_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QAbstractSpinBox_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setStyleSheet(QString(styleSheet));
}

void QAbstractSpinBox_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QAbstractSpinBox_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setVisible(visible != 0);
}

void QAbstractSpinBox_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QAbstractSpinBox_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setWindowModified(vbo != 0);
}

void QAbstractSpinBox_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QAbstractSpinBox_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setWindowTitle(QString(vqs));
}

char QAbstractSpinBox_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QAbstractSpinBox_CloseDefault(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::close();
}

char QAbstractSpinBox_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QAbstractSpinBox*>(ptr)->focusNextPrevChild(next != 0);
}

char QAbstractSpinBox_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::focusNextPrevChild(next != 0);
}

char QAbstractSpinBox_HasHeightForWidth(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->hasHeightForWidth();
}

char QAbstractSpinBox_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::hasHeightForWidth();
}

int QAbstractSpinBox_HeightForWidth(void* ptr, int w)
{
	return static_cast<QAbstractSpinBox*>(ptr)->heightForWidth(w);
}

int QAbstractSpinBox_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::heightForWidth(w);
}

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

void QAbstractSpinBox_HideDefault(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::hide();
}

void QAbstractSpinBox_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QAbstractSpinBox_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

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

void QAbstractSpinBox_LowerDefault(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::lower();
}

void QAbstractSpinBox_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QAbstractSpinBox_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QAbstractSpinBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QAbstractSpinBox*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QAbstractSpinBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

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

void QAbstractSpinBox_RaiseDefault(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::raise();
}

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

void QAbstractSpinBox_RepaintDefault(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::repaint();
}

void QAbstractSpinBox_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QAbstractSpinBox_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setDisabled(disable != 0);
}

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

void QAbstractSpinBox_SetFocus2Default(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setFocus();
}

void QAbstractSpinBox_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QAbstractSpinBox_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setHidden(hidden != 0);
}

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

void QAbstractSpinBox_ShowDefault(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::show();
}

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

void QAbstractSpinBox_ShowFullScreenDefault(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::showFullScreen();
}

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

void QAbstractSpinBox_ShowMaximizedDefault(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::showMaximized();
}

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

void QAbstractSpinBox_ShowMinimizedDefault(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::showMinimized();
}

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

void QAbstractSpinBox_ShowNormalDefault(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::showNormal();
}

void QAbstractSpinBox_TabletEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QAbstractSpinBox_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::tabletEvent(static_cast<QTabletEvent*>(event));
}

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

void QAbstractSpinBox_UpdateDefault(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::update();
}

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

void QAbstractSpinBox_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::updateMicroFocus();
}

void QAbstractSpinBox_ChildEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QAbstractSpinBox_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QAbstractSpinBox*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QAbstractSpinBox_CustomEvent(void* ptr, void* event)
{
	static_cast<QAbstractSpinBox*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

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

void QAbstractSpinBox_DeleteLaterDefault(void* ptr)
{
	static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::deleteLater();
}

void QAbstractSpinBox_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QAbstractSpinBox*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QAbstractSpinBox_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractSpinBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QAbstractSpinBox_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QAbstractSpinBox_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QAbstractSpinBox*>(ptr)->metaObject());
}

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

char* QAccessibleWidget_ActionNames(void* ptr)
{
	return const_cast<char*>(static_cast<QAccessibleWidget*>(ptr)->actionNames().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

void QAccessibleWidget_AddControllingSignal(void* ptr, char* sign)
{
	static_cast<QAccessibleWidget*>(ptr)->addControllingSignal(QString(sign));
}

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

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

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

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

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

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

int QAccessibleWidget_IndexOfChild(void* ptr, void* child)
{
	return static_cast<QAccessibleWidget*>(ptr)->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));
}

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

char* QAccessibleWidget_KeyBindingsForAction(void* ptr, char* actionName)
{
	return const_cast<char*>(static_cast<QAccessibleWidget*>(ptr)->keyBindingsForAction(QString(actionName)).join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QAccessibleWidget_Parent(void* ptr)
{
	return static_cast<QAccessibleWidget*>(ptr)->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()); });
}

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

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

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

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

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

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, char* text)
{
	static_cast<QAccessibleWidget*>(ptr)->setText(static_cast<QAccessible::Text>(t), QString(text));
}

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

char* QAccessibleWidget_LocalizedActionDescription(void* ptr, char* actionName)
{
	return const_cast<char*>(static_cast<QAccessibleWidget*>(ptr)->localizedActionDescription(QString(actionName)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QAccessibleWidget_LocalizedActionDescriptionDefault(void* ptr, char* actionName)
{
	return const_cast<char*>(static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::localizedActionDescription(QString(actionName)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QAccessibleWidget_LocalizedActionName(void* ptr, char* actionName)
{
	return const_cast<char*>(static_cast<QAccessibleWidget*>(ptr)->localizedActionName(QString(actionName)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QAccessibleWidget_LocalizedActionNameDefault(void* ptr, char* actionName)
{
	return const_cast<char*>(static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::localizedActionName(QString(actionName)).toUtf8().prepend("WHITESPACE").constData()+10);
}

class MyQAction: public QAction
{
public:
	MyQAction(QObject *parent) : QAction(parent) {};
	MyQAction(const QIcon &icon, const QString &text, QObject *parent) : QAction(icon, text, parent) {};
	MyQAction(const QString &text, QObject *parent) : QAction(text, parent) {};
	void setChecked(bool vbo) { callbackQAction_SetChecked(this, vbo); };
	void setEnabled(bool vbo) { callbackQAction_SetEnabled(this, vbo); };
	void setVisible(bool vbo) { callbackQAction_SetVisible(this, vbo); };
	void toggle() { callbackQAction_Toggle(this); };
	void Signal_Changed() { callbackQAction_Changed(this); };
	void hover() { callbackQAction_Hover(this); };
	void Signal_Hovered() { callbackQAction_Hovered(this); };
	void setDisabled(bool b) { callbackQAction_SetDisabled(this, b); };
	void Signal_Toggled(bool checked) { callbackQAction_Toggled(this, checked); };
	void trigger() { callbackQAction_Trigger(this); };
	void Signal_Triggered(bool checked) { callbackQAction_Triggered(this, checked); };
	void timerEvent(QTimerEvent * event) { callbackQAction_TimerEvent(this, event); };
	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 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<MyQAction*>(this))); };
};

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

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

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

char* QAction_IconText(void* ptr)
{
	return const_cast<char*>(static_cast<QAction*>(ptr)->iconText().toUtf8().prepend("WHITESPACE").constData()+10);
}

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_IsVisible(void* ptr)
{
	return static_cast<QAction*>(ptr)->isVisible();
}

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

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

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_SetData(void* ptr, void* userData)
{
	static_cast<QAction*>(ptr)->setData(*static_cast<QVariant*>(userData));
}

void QAction_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QAction*>(ptr), "setEnabled", Q_ARG(bool, 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, char* text)
{
	static_cast<QAction*>(ptr)->setIconText(QString(text));
}

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

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_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_SetStatusTip(void* ptr, char* statusTip)
{
	static_cast<QAction*>(ptr)->setStatusTip(QString(statusTip));
}

void QAction_SetText(void* ptr, char* text)
{
	static_cast<QAction*>(ptr)->setText(QString(text));
}

void QAction_SetToolTip(void* ptr, char* tip)
{
	static_cast<QAction*>(ptr)->setToolTip(QString(tip));
}

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

void QAction_SetWhatsThis(void* ptr, char* what)
{
	static_cast<QAction*>(ptr)->setWhatsThis(QString(what));
}

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

char* QAction_StatusTip(void* ptr)
{
	return const_cast<char*>(static_cast<QAction*>(ptr)->statusTip().toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QAction_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QAction*>(ptr)->text().toUtf8().prepend("WHITESPACE").constData()+10);
}

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

char* QAction_ToolTip(void* ptr)
{
	return const_cast<char*>(static_cast<QAction*>(ptr)->toolTip().toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QAction_WhatsThis(void* ptr)
{
	return const_cast<char*>(static_cast<QAction*>(ptr)->whatsThis().toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QAction_NewQAction(void* parent)
{
	return new MyQAction(static_cast<QObject*>(parent));
}

void* QAction_NewQAction3(void* icon, char* text, void* parent)
{
	return new MyQAction(*static_cast<QIcon*>(icon), QString(text), static_cast<QObject*>(parent));
}

void* QAction_NewQAction2(char* text, void* parent)
{
	return new MyQAction(QString(text), 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));
}

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

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_Event(void* ptr, void* e)
{
	return static_cast<QAction*>(ptr)->event(static_cast<QEvent*>(e));
}

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

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

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();
}

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

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

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

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

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

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

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

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

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

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

void QAction_ConnectToggled(void* ptr)
{
	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));
}

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);
}

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

void QAction_ConnectTriggered(void* ptr)
{
	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));
}

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);
}

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

void QAction_TimerEvent(void* ptr, void* event)
{
	static_cast<QAction*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QAction_ChildEvent(void* ptr, void* event)
{
	static_cast<QAction*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QAction_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QAction*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QAction_CustomEvent(void* ptr, void* event)
{
	static_cast<QAction*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

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

void QAction_DeleteLaterDefault(void* ptr)
{
	static_cast<QAction*>(ptr)->QAction::deleteLater();
}

void QAction_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QAction*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QAction_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QAction*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QAction_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QAction*>(ptr)->QAction::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QAction_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QAction*>(ptr)->metaObject());
}

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

class MyQActionGroup: public QActionGroup
{
public:
	MyQActionGroup(QObject *parent) : QActionGroup(parent) {};
	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_Hovered(QAction * action) { callbackQActionGroup_Hovered(this, action); };
	void setDisabled(bool b) { callbackQActionGroup_SetDisabled(this, b); };
	void Signal_Triggered(QAction * action) { callbackQActionGroup_Triggered(this, action); };
	void timerEvent(QTimerEvent * event) { callbackQActionGroup_TimerEvent(this, event); };
	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 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<MyQActionGroup*>(this))); };
};

void* QActionGroup_AddAction(void* ptr, void* action)
{
	return static_cast<QActionGroup*>(ptr)->addAction(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_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QActionGroup*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

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

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

void* QActionGroup_NewQActionGroup(void* parent)
{
	return new MyQActionGroup(static_cast<QObject*>(parent));
}

void* QActionGroup_AddAction3(void* ptr, void* icon, char* text)
{
	return static_cast<QActionGroup*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString(text));
}

void* QActionGroup_AddAction2(void* ptr, char* text)
{
	return static_cast<QActionGroup*>(ptr)->addAction(QString(text));
}

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

void QActionGroup_ConnectHovered(void* ptr)
{
	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));
}

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));
}

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_ConnectTriggered(void* ptr)
{
	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));
}

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_TimerEvent(void* ptr, void* event)
{
	static_cast<QActionGroup*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

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

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

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

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

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

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

void QActionGroup_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QActionGroup*>(ptr), "deleteLater");
}

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

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

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

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

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

char QActionGroup_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QActionGroup*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QActionGroup_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QActionGroup*>(ptr)->QActionGroup::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

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

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

class MyQApplication: public QApplication
{
public:
	MyQApplication(int &argc, char **argv) : QApplication(argc, argv) {};
	int autoMaximizeThreshold() const { return callbackQApplication_AutoMaximizeThreshold(const_cast<MyQApplication*>(this)); };
	bool autoSipEnabled() const { return callbackQApplication_AutoSipEnabled(const_cast<MyQApplication*>(this)) != 0; };
	void setAutoMaximizeThreshold(const int threshold) { callbackQApplication_SetAutoMaximizeThreshold(this, threshold); };
	void setAutoSipEnabled(const bool enabled) { callbackQApplication_SetAutoSipEnabled(this, enabled); };
	void setStyleSheet(const QString & sheet) { callbackQApplication_SetStyleSheet(this, const_cast<char*>(sheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void aboutQt() { callbackQApplication_AboutQt(this); };
	void closeAllWindows() { callbackQApplication_CloseAllWindows(this); };
	void Signal_FocusChanged(QWidget * old, QWidget * now) { callbackQApplication_FocusChanged(this, old, now); };
	 ~MyQApplication() { callbackQApplication_DestroyQApplication(this); };
	void quit() { callbackQApplication_Quit(this); };
	void timerEvent(QTimerEvent * event) { callbackQApplication_TimerEvent(this, event); };
	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 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<MyQApplication*>(this))); };
};

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

int QApplication_AutoMaximizeThreshold(void* ptr)
{
	int returnArg;
	QMetaObject::invokeMethod(static_cast<QApplication*>(ptr), "autoMaximizeThreshold", Q_RETURN_ARG(int, returnArg));
	return returnArg;
}

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

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

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

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

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();
}

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

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

void QApplication_SetAutoMaximizeThreshold(void* ptr, int threshold)
{
	QMetaObject::invokeMethod(static_cast<QApplication*>(ptr), "setAutoMaximizeThreshold", Q_ARG(int, threshold));
}

void QApplication_SetAutoSipEnabled(void* ptr, char enabled)
{
	QMetaObject::invokeMethod(static_cast<QApplication*>(ptr), "setAutoSipEnabled", Q_ARG(bool, 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_SetGlobalStrut(void* vqs)
{
	QApplication::setGlobalStrut(*static_cast<QSize*>(vqs));
}

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

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

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

void QApplication_SetStyleSheet(void* ptr, char* sheet)
{
	QMetaObject::invokeMethod(static_cast<QApplication*>(ptr), "setStyleSheet", Q_ARG(QString, QString(sheet)));
}

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();
}

char* QApplication_StyleSheet(void* ptr)
{
	return const_cast<char*>(static_cast<QApplication*>(ptr)->styleSheet().toUtf8().prepend("WHITESPACE").constData()+10);
}

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

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

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

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

void* QApplication_NewQApplication(int argc, char* argv)
{
	QList<QByteArray> aList = QByteArray(argv).split('|');
	char *argvs[argc];
	static int argcs = argc;
	for (int i = 0; i < argc; i++)
		argvs[i] = const_cast<char*>(aList[i].constData());

	return new MyQApplication(argcs, argvs);
}

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

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

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

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

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

int QApplication_QApplication_ColorSpec()
{
	return QApplication::colorSpec();
}

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

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

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

void QApplication_ConnectFocusChanged(void* ptr)
{
	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));
}

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());
}

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

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

void QApplication_QApplication_SetColorSpec(int spec)
{
	QApplication::setColorSpec(spec);
}

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

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_SetStyle2(char* style)
{
	return QApplication::setStyle(QString(style));
}

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

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

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

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

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

void QApplication_DestroyQApplicationDefault(void* ptr)
{

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

char QApplication_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QApplication*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QApplication_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QApplication*>(ptr)->QApplication::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

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

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

class MyQBoxLayout: public QBoxLayout
{
public:
	MyQBoxLayout(Direction dir, QWidget *parent) : QBoxLayout(dir, parent) {};
	void addItem(QLayoutItem * item) { callbackQBoxLayout_AddItem(this, item); };
	int count() const { return callbackQBoxLayout_Count(const_cast<MyQBoxLayout*>(this)); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQBoxLayout_ExpandingDirections(const_cast<MyQBoxLayout*>(this))); };
	bool hasHeightForWidth() const { return callbackQBoxLayout_HasHeightForWidth(const_cast<MyQBoxLayout*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQBoxLayout_HeightForWidth(const_cast<MyQBoxLayout*>(this), w); };
	void invalidate() { callbackQBoxLayout_Invalidate(this); };
	QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQBoxLayout_ItemAt(const_cast<MyQBoxLayout*>(this), index)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQBoxLayout_MaximumSize(const_cast<MyQBoxLayout*>(this))); };
	int minimumHeightForWidth(int w) const { return callbackQBoxLayout_MinimumHeightForWidth(const_cast<MyQBoxLayout*>(this), w); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQBoxLayout_MinimumSize(const_cast<MyQBoxLayout*>(this))); };
	void setGeometry(const QRect & r) { callbackQBoxLayout_SetGeometry(this, const_cast<QRect*>(&r)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQBoxLayout_SizeHint(const_cast<MyQBoxLayout*>(this))); };
	QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQBoxLayout_TakeAt(this, index)); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQBoxLayout_ControlTypes(const_cast<MyQBoxLayout*>(this))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQBoxLayout_Geometry(const_cast<MyQBoxLayout*>(this))); };
	int indexOf(QWidget * widget) const { return callbackQBoxLayout_IndexOf(const_cast<MyQBoxLayout*>(this), widget); };
	bool isEmpty() const { return callbackQBoxLayout_IsEmpty(const_cast<MyQBoxLayout*>(this)) != 0; };
	QLayout * layout() { return static_cast<QLayout*>(callbackQBoxLayout_Layout(this)); };
	void timerEvent(QTimerEvent * event) { callbackQBoxLayout_TimerEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQBoxLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQBoxLayout_CustomEvent(this, event); };
	void deleteLater() { callbackQBoxLayout_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQBoxLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQBoxLayout_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQBoxLayout_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQBoxLayout_MetaObject(const_cast<MyQBoxLayout*>(this))); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQBoxLayout_SpacerItem(this)); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQBoxLayout_Widget(this)); };
};

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

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)
{
	static_cast<QBoxLayout*>(ptr)->addItem(static_cast<QLayoutItem*>(item));
}

void QBoxLayout_AddItemDefault(void* ptr, void* item)
{
	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)
{
	return static_cast<QBoxLayout*>(ptr)->QBoxLayout::count();
}

long long QBoxLayout_ExpandingDirections(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->expandingDirections();
}

long long QBoxLayout_ExpandingDirectionsDefault(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->QBoxLayout::expandingDirections();
}

char QBoxLayout_HasHeightForWidth(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->hasHeightForWidth();
}

char QBoxLayout_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->QBoxLayout::hasHeightForWidth();
}

int QBoxLayout_HeightForWidth(void* ptr, int w)
{
	return static_cast<QBoxLayout*>(ptr)->heightForWidth(w);
}

int QBoxLayout_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QBoxLayout*>(ptr)->QBoxLayout::heightForWidth(w);
}

void QBoxLayout_InsertItem(void* ptr, int index, void* item)
{
	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_Invalidate(void* ptr)
{
	static_cast<QBoxLayout*>(ptr)->invalidate();
}

void QBoxLayout_InvalidateDefault(void* ptr)
{
	static_cast<QBoxLayout*>(ptr)->QBoxLayout::invalidate();
}

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

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

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

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

int QBoxLayout_MinimumHeightForWidth(void* ptr, int w)
{
	return static_cast<QBoxLayout*>(ptr)->minimumHeightForWidth(w);
}

int QBoxLayout_MinimumHeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QBoxLayout*>(ptr)->QBoxLayout::minimumHeightForWidth(w);
}

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

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

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

void QBoxLayout_SetGeometry(void* ptr, void* r)
{
	static_cast<QBoxLayout*>(ptr)->setGeometry(*static_cast<QRect*>(r));
}

void QBoxLayout_SetGeometryDefault(void* ptr, void* r)
{
	static_cast<QBoxLayout*>(ptr)->QBoxLayout::setGeometry(*static_cast<QRect*>(r));
}

void QBoxLayout_SetSpacing(void* ptr, int spacing)
{
	static_cast<QBoxLayout*>(ptr)->setSpacing(spacing);
}

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

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

char QBoxLayout_SetStretchFactor(void* ptr, void* widget, int stretch)
{
	return static_cast<QBoxLayout*>(ptr)->setStretchFactor(static_cast<QWidget*>(widget), 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)
{
	return ({ QSize tmpValue = static_cast<QBoxLayout*>(ptr)->QBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QBoxLayout_Spacing(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->spacing();
}

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)
{
	return static_cast<QBoxLayout*>(ptr)->QBoxLayout::takeAt(index);
}

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

long long QBoxLayout_ControlTypes(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->controlTypes();
}

long long QBoxLayout_ControlTypesDefault(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->QBoxLayout::controlTypes();
}

void* QBoxLayout_Geometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QBoxLayout*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

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

int QBoxLayout_IndexOf(void* ptr, void* widget)
{
	return static_cast<QBoxLayout*>(ptr)->indexOf(static_cast<QWidget*>(widget));
}

int QBoxLayout_IndexOfDefault(void* ptr, void* widget)
{
	return static_cast<QBoxLayout*>(ptr)->QBoxLayout::indexOf(static_cast<QWidget*>(widget));
}

char QBoxLayout_IsEmpty(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->isEmpty();
}

char QBoxLayout_IsEmptyDefault(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->QBoxLayout::isEmpty();
}

void* QBoxLayout_Layout(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->layout();
}

void* QBoxLayout_LayoutDefault(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->QBoxLayout::layout();
}

void QBoxLayout_TimerEvent(void* ptr, void* event)
{
	static_cast<QBoxLayout*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QBoxLayout_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QBoxLayout*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QBoxLayout_CustomEvent(void* ptr, void* event)
{
	static_cast<QBoxLayout*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QBoxLayout_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QBoxLayout*>(ptr), "deleteLater");
}

void QBoxLayout_DeleteLaterDefault(void* ptr)
{
	static_cast<QBoxLayout*>(ptr)->QBoxLayout::deleteLater();
}

void QBoxLayout_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QBoxLayout*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QBoxLayout_Event(void* ptr, void* e)
{
	return static_cast<QBoxLayout*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QBoxLayout_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QBoxLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QBoxLayout_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QBoxLayout*>(ptr)->QBoxLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QBoxLayout_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QBoxLayout*>(ptr)->metaObject());
}

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

void* QBoxLayout_SpacerItem(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->spacerItem();
}

void* QBoxLayout_SpacerItemDefault(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->QBoxLayout::spacerItem();
}

void* QBoxLayout_Widget(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->widget();
}

void* QBoxLayout_WidgetDefault(void* ptr)
{
	return static_cast<QBoxLayout*>(ptr)->QBoxLayout::widget();
}

class MyQButtonGroup: public QButtonGroup
{
public:
	MyQButtonGroup(QObject *parent) : QButtonGroup(parent) {};
	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); };
	void timerEvent(QTimerEvent * event) { callbackQButtonGroup_TimerEvent(this, event); };
	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 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<MyQButtonGroup*>(this))); };
};

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

void QButtonGroup_SetExclusive(void* ptr, char vbo)
{
	static_cast<QButtonGroup*>(ptr)->setExclusive(vbo != 0);
}

void* QButtonGroup_NewQButtonGroup(void* parent)
{
	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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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);
}

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

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

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_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_TimerEvent(void* ptr, void* event)
{
	static_cast<QButtonGroup*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QButtonGroup_ChildEvent(void* ptr, void* event)
{
	static_cast<QButtonGroup*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QButtonGroup_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QButtonGroup*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QButtonGroup_CustomEvent(void* ptr, void* event)
{
	static_cast<QButtonGroup*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QButtonGroup_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QButtonGroup*>(ptr), "deleteLater");
}

void QButtonGroup_DeleteLaterDefault(void* ptr)
{
	static_cast<QButtonGroup*>(ptr)->QButtonGroup::deleteLater();
}

void QButtonGroup_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QButtonGroup*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QButtonGroup_Event(void* ptr, void* e)
{
	return static_cast<QButtonGroup*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QButtonGroup_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QButtonGroup*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QButtonGroup_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QButtonGroup*>(ptr)->QButtonGroup::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QButtonGroup_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QButtonGroup*>(ptr)->metaObject());
}

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

class MyQCalendarWidget: public QCalendarWidget
{
public:
	MyQCalendarWidget(QWidget *parent) : QCalendarWidget(parent) {};
	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 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); };
	void keyPressEvent(QKeyEvent * event) { callbackQCalendarWidget_KeyPressEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQCalendarWidget_MinimumSizeHint(const_cast<MyQCalendarWidget*>(this))); };
	void mousePressEvent(QMouseEvent * event) { callbackQCalendarWidget_MousePressEvent(this, event); };
	void paintCell(QPainter * painter, const QRect & rect, const QDate & date) const { callbackQCalendarWidget_PaintCell(const_cast<MyQCalendarWidget*>(this), painter, const_cast<QRect*>(&rect), const_cast<QDate*>(&date)); };
	void resizeEvent(QResizeEvent * event) { callbackQCalendarWidget_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 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*>(callbackQCalendarWidget_SizeHint(const_cast<MyQCalendarWidget*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQCalendarWidget_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQCalendarWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQCalendarWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQCalendarWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQCalendarWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQCalendarWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQCalendarWidget_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQCalendarWidget_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQCalendarWidget_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQCalendarWidget_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQCalendarWidget_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQCalendarWidget_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQCalendarWidget_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQCalendarWidget_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQCalendarWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQCalendarWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQCalendarWidget_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQCalendarWidget_ShowEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQCalendarWidget_ChangeEvent(this, event); };
	bool close() { return callbackQCalendarWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQCalendarWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQCalendarWidget_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQCalendarWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQCalendarWidget_HasHeightForWidth(const_cast<MyQCalendarWidget*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQCalendarWidget_HeightForWidth(const_cast<MyQCalendarWidget*>(this), w); };
	void hide() { callbackQCalendarWidget_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQCalendarWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQCalendarWidget_InputMethodQuery(const_cast<MyQCalendarWidget*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQCalendarWidget_KeyReleaseEvent(this, event); };
	void lower() { callbackQCalendarWidget_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQCalendarWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQCalendarWidget_MouseMoveEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQCalendarWidget_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQCalendarWidget_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQCalendarWidget_Raise(this); };
	void repaint() { callbackQCalendarWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQCalendarWidget_SetDisabled(this, disable); };
	void setFocus() { callbackQCalendarWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQCalendarWidget_SetHidden(this, hidden); };
	void show() { callbackQCalendarWidget_Show(this); };
	void showFullScreen() { callbackQCalendarWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQCalendarWidget_ShowMaximized(this); };
	void showMinimized() { callbackQCalendarWidget_ShowMinimized(this); };
	void showNormal() { callbackQCalendarWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQCalendarWidget_TabletEvent(this, event); };
	void update() { callbackQCalendarWidget_Update(this); };
	void updateMicroFocus() { callbackQCalendarWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQCalendarWidget_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQCalendarWidget_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQCalendarWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQCalendarWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQCalendarWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQCalendarWidget_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQCalendarWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCalendarWidget_MetaObject(const_cast<MyQCalendarWidget*>(this))); };
};

int QCalendarWidget_DateEditAcceptDelay(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->dateEditAcceptDelay();
}

long long QCalendarWidget_FirstDayOfWeek(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->firstDayOfWeek();
}

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();
}

long long QCalendarWidget_SelectionMode(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->selectionMode();
}

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_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_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_SetSelectedDate(void* ptr, void* date)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setSelectedDate", Q_ARG(QDate, *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));
}

long long QCalendarWidget_VerticalHeaderFormat(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->verticalHeaderFormat();
}

void* QCalendarWidget_NewQCalendarWidget(void* parent)
{
	return new MyQCalendarWidget(static_cast<QWidget*>(parent));
}

void QCalendarWidget_ConnectActivated(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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);
}

char QCalendarWidget_Event(void* ptr, void* event)
{
	return static_cast<QCalendarWidget*>(ptr)->event(static_cast<QEvent*>(event));
}

char QCalendarWidget_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QCalendarWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void QCalendarWidget_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QCalendarWidget_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void* QCalendarWidget_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QCalendarWidget*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QCalendarWidget_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QCalendarWidget_MonthShown(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->monthShown();
}

void QCalendarWidget_MousePressEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QCalendarWidget_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
}

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_ResizeEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QCalendarWidget_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QCalendarWidget_ConnectSelectionChanged(void* ptr)
{
	QObject::connect(static_cast<QCalendarWidget*>(ptr), static_cast<void (QCalendarWidget::*)()>(&QCalendarWidget::selectionChanged), static_cast<MyQCalendarWidget*>(ptr), static_cast<void (MyQCalendarWidget::*)()>(&MyQCalendarWidget::Signal_SelectionChanged));
}

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();
}

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_SetDateRange(void* ptr, void* min, void* max)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setDateRange", Q_ARG(QDate, *static_cast<QDate*>(min)), Q_ARG(QDate, *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_SetHeaderTextFormat(void* ptr, void* format)
{
	static_cast<QCalendarWidget*>(ptr)->setHeaderTextFormat(*static_cast<QTextCharFormat*>(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_ShowNextYear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showNextYear");
}

void QCalendarWidget_ShowPreviousMonth(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showPreviousMonth");
}

void QCalendarWidget_ShowPreviousYear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showPreviousYear");
}

void QCalendarWidget_ShowSelectedDate(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showSelectedDate");
}

void QCalendarWidget_ShowToday(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showToday");
}

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

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

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();
}

int QCalendarWidget_YearShown(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->yearShown();
}

void QCalendarWidget_DestroyQCalendarWidget(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->~QCalendarWidget();
}

void QCalendarWidget_ActionEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QCalendarWidget_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::actionEvent(static_cast<QActionEvent*>(event));
}

void QCalendarWidget_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QCalendarWidget_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QCalendarWidget_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QCalendarWidget_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QCalendarWidget_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QCalendarWidget_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QCalendarWidget_DropEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QCalendarWidget_DropEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::dropEvent(static_cast<QDropEvent*>(event));
}

void QCalendarWidget_EnterEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QCalendarWidget_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::enterEvent(static_cast<QEvent*>(event));
}

void QCalendarWidget_FocusInEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QCalendarWidget_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QCalendarWidget_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QCalendarWidget_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QCalendarWidget_HideEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QCalendarWidget_HideEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::hideEvent(static_cast<QHideEvent*>(event));
}

void QCalendarWidget_LeaveEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QCalendarWidget_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::leaveEvent(static_cast<QEvent*>(event));
}

void QCalendarWidget_MoveEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QCalendarWidget_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::moveEvent(static_cast<QMoveEvent*>(event));
}

void QCalendarWidget_PaintEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QCalendarWidget_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::paintEvent(static_cast<QPaintEvent*>(event));
}

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

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

void QCalendarWidget_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QCalendarWidget_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setStyleSheet(QString(styleSheet));
}

void QCalendarWidget_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QCalendarWidget_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setVisible(visible != 0);
}

void QCalendarWidget_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QCalendarWidget_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setWindowModified(vbo != 0);
}

void QCalendarWidget_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QCalendarWidget_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setWindowTitle(QString(vqs));
}

void QCalendarWidget_ShowEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QCalendarWidget_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showEvent(static_cast<QShowEvent*>(event));
}

void QCalendarWidget_ChangeEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QCalendarWidget_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::changeEvent(static_cast<QEvent*>(event));
}

char QCalendarWidget_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QCalendarWidget_CloseDefault(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::close();
}

void QCalendarWidget_CloseEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QCalendarWidget_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::closeEvent(static_cast<QCloseEvent*>(event));
}

void QCalendarWidget_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QCalendarWidget_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QCalendarWidget_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QCalendarWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QCalendarWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::focusNextPrevChild(next != 0);
}

char QCalendarWidget_HasHeightForWidth(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->hasHeightForWidth();
}

char QCalendarWidget_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::hasHeightForWidth();
}

int QCalendarWidget_HeightForWidth(void* ptr, int w)
{
	return static_cast<QCalendarWidget*>(ptr)->heightForWidth(w);
}

int QCalendarWidget_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::heightForWidth(w);
}

void QCalendarWidget_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "hide");
}

void QCalendarWidget_HideDefault(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::hide();
}

void QCalendarWidget_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QCalendarWidget_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QCalendarWidget_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QCalendarWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QCalendarWidget_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QCalendarWidget_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QCalendarWidget_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QCalendarWidget_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "lower");
}

void QCalendarWidget_LowerDefault(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::lower();
}

void QCalendarWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QCalendarWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QCalendarWidget_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QCalendarWidget_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QCalendarWidget_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QCalendarWidget_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QCalendarWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QCalendarWidget*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QCalendarWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QCalendarWidget_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "raise");
}

void QCalendarWidget_RaiseDefault(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::raise();
}

void QCalendarWidget_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "repaint");
}

void QCalendarWidget_RepaintDefault(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::repaint();
}

void QCalendarWidget_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QCalendarWidget_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setDisabled(disable != 0);
}

void QCalendarWidget_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setFocus");
}

void QCalendarWidget_SetFocus2Default(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setFocus();
}

void QCalendarWidget_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QCalendarWidget_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setHidden(hidden != 0);
}

void QCalendarWidget_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "show");
}

void QCalendarWidget_ShowDefault(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::show();
}

void QCalendarWidget_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showFullScreen");
}

void QCalendarWidget_ShowFullScreenDefault(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showFullScreen();
}

void QCalendarWidget_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showMaximized");
}

void QCalendarWidget_ShowMaximizedDefault(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showMaximized();
}

void QCalendarWidget_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showMinimized");
}

void QCalendarWidget_ShowMinimizedDefault(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showMinimized();
}

void QCalendarWidget_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "showNormal");
}

void QCalendarWidget_ShowNormalDefault(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::showNormal();
}

void QCalendarWidget_TabletEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QCalendarWidget_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QCalendarWidget_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "update");
}

void QCalendarWidget_UpdateDefault(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::update();
}

void QCalendarWidget_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "updateMicroFocus");
}

void QCalendarWidget_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::updateMicroFocus();
}

void QCalendarWidget_WheelEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QCalendarWidget_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QCalendarWidget_TimerEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QCalendarWidget_ChildEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QCalendarWidget_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QCalendarWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QCalendarWidget_CustomEvent(void* ptr, void* event)
{
	static_cast<QCalendarWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QCalendarWidget_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "deleteLater");
}

void QCalendarWidget_DeleteLaterDefault(void* ptr)
{
	static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::deleteLater();
}

void QCalendarWidget_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QCalendarWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void* QCalendarWidget_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QCalendarWidget*>(ptr)->metaObject());
}

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

class MyQCheckBox: public QCheckBox
{
public:
	MyQCheckBox(QWidget *parent) : QCheckBox(parent) {};
	MyQCheckBox(const QString &text, QWidget *parent) : QCheckBox(text, parent) {};
	void checkStateSet() { callbackQCheckBox_CheckStateSet(this); };
	bool hitButton(const QPoint & pos) const { return callbackQCheckBox_HitButton(const_cast<MyQCheckBox*>(this), const_cast<QPoint*>(&pos)) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQCheckBox_MinimumSizeHint(const_cast<MyQCheckBox*>(this))); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQCheckBox_MouseMoveEvent(this, e); };
	void nextCheckState() { callbackQCheckBox_NextCheckState(this); };
	void paintEvent(QPaintEvent * vqp) { callbackQCheckBox_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQCheckBox_SizeHint(const_cast<MyQCheckBox*>(this))); };
	void Signal_StateChanged(int state) { callbackQCheckBox_StateChanged(this, state); };
	void setChecked(bool vbo) { callbackQCheckBox_SetChecked(this, vbo); };
	void setIconSize(const QSize & size) { callbackQCheckBox_SetIconSize(this, const_cast<QSize*>(&size)); };
	void toggle() { callbackQCheckBox_Toggle(this); };
	void animateClick(int msec) { callbackQCheckBox_AnimateClick(this, msec); };
	void changeEvent(QEvent * e) { callbackQCheckBox_ChangeEvent(this, e); };
	void click() { callbackQCheckBox_Click(this); };
	void focusInEvent(QFocusEvent * e) { callbackQCheckBox_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQCheckBox_FocusOutEvent(this, e); };
	void keyPressEvent(QKeyEvent * e) { callbackQCheckBox_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQCheckBox_KeyReleaseEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQCheckBox_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQCheckBox_MouseReleaseEvent(this, e); };
	void actionEvent(QActionEvent * event) { callbackQCheckBox_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQCheckBox_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQCheckBox_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQCheckBox_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQCheckBox_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQCheckBox_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQCheckBox_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQCheckBox_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQCheckBox_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQCheckBox_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQCheckBox_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQCheckBox_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQCheckBox_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQCheckBox_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQCheckBox_ShowEvent(this, event); };
	bool close() { return callbackQCheckBox_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQCheckBox_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQCheckBox_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQCheckBox_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQCheckBox_HasHeightForWidth(const_cast<MyQCheckBox*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQCheckBox_HeightForWidth(const_cast<MyQCheckBox*>(this), w); };
	void hide() { callbackQCheckBox_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQCheckBox_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQCheckBox_InputMethodQuery(const_cast<MyQCheckBox*>(this), query)); };
	void lower() { callbackQCheckBox_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQCheckBox_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQCheckBox_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQCheckBox_Raise(this); };
	void repaint() { callbackQCheckBox_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQCheckBox_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQCheckBox_SetDisabled(this, disable); };
	void setFocus() { callbackQCheckBox_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQCheckBox_SetHidden(this, hidden); };
	void show() { callbackQCheckBox_Show(this); };
	void showFullScreen() { callbackQCheckBox_ShowFullScreen(this); };
	void showMaximized() { callbackQCheckBox_ShowMaximized(this); };
	void showMinimized() { callbackQCheckBox_ShowMinimized(this); };
	void showNormal() { callbackQCheckBox_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQCheckBox_TabletEvent(this, event); };
	void update() { callbackQCheckBox_Update(this); };
	void updateMicroFocus() { callbackQCheckBox_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQCheckBox_WheelEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQCheckBox_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQCheckBox_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQCheckBox_CustomEvent(this, event); };
	void deleteLater() { callbackQCheckBox_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQCheckBox_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQCheckBox_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCheckBox_MetaObject(const_cast<MyQCheckBox*>(this))); };
};

char QCheckBox_IsTristate(void* ptr)
{
	return static_cast<QCheckBox*>(ptr)->isTristate();
}

void QCheckBox_SetTristate(void* ptr, char y)
{
	static_cast<QCheckBox*>(ptr)->setTristate(y != 0);
}

void* QCheckBox_NewQCheckBox(void* parent)
{
	return new MyQCheckBox(static_cast<QWidget*>(parent));
}

void* QCheckBox_NewQCheckBox2(char* text, void* parent)
{
	return new MyQCheckBox(QString(text), static_cast<QWidget*>(parent));
}

long long QCheckBox_CheckState(void* ptr)
{
	return static_cast<QCheckBox*>(ptr)->checkState();
}

void QCheckBox_CheckStateSet(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->checkStateSet();
}

void QCheckBox_CheckStateSetDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::checkStateSet();
}

char QCheckBox_Event(void* ptr, void* e)
{
	return static_cast<QCheckBox*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QCheckBox_HitButtonDefault(void* ptr, void* pos)
{
	return static_cast<QCheckBox*>(ptr)->QCheckBox::hitButton(*static_cast<QPoint*>(pos));
}

void QCheckBox_InitStyleOption(void* ptr, void* option)
{
	static_cast<QCheckBox*>(ptr)->initStyleOption(static_cast<QStyleOptionButton*>(option));
}

void* QCheckBox_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QCheckBox*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QCheckBox_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QCheckBox*>(ptr)->QCheckBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QCheckBox_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QCheckBox_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QCheckBox_NextCheckState(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->nextCheckState();
}

void QCheckBox_NextCheckStateDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::nextCheckState();
}

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_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QCheckBox*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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

void QCheckBox_ConnectStateChanged(void* ptr)
{
	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));
}

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_SetChecked(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}

void QCheckBox_SetCheckedDefault(void* ptr, char vbo)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::setChecked(vbo != 0);
}

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

void QCheckBox_SetIconSizeDefault(void* ptr, void* size)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::setIconSize(*static_cast<QSize*>(size));
}

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

void QCheckBox_ToggleDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::toggle();
}

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

void QCheckBox_AnimateClickDefault(void* ptr, int msec)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::animateClick(msec);
}

void QCheckBox_ChangeEvent(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QCheckBox_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::changeEvent(static_cast<QEvent*>(e));
}

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

void QCheckBox_ClickDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::click();
}

void QCheckBox_FocusInEvent(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(e));
}

void QCheckBox_FocusInEventDefault(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::focusInEvent(static_cast<QFocusEvent*>(e));
}

void QCheckBox_FocusOutEvent(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QCheckBox_FocusOutEventDefault(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QCheckBox_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QCheckBox_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QCheckBox_KeyReleaseEvent(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QCheckBox_KeyReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QCheckBox_MousePressEvent(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QCheckBox_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QCheckBox_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QCheckBox_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QCheckBox_ActionEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QCheckBox_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::actionEvent(static_cast<QActionEvent*>(event));
}

void QCheckBox_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QCheckBox_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QCheckBox_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QCheckBox_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QCheckBox_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QCheckBox_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QCheckBox_DropEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QCheckBox_DropEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::dropEvent(static_cast<QDropEvent*>(event));
}

void QCheckBox_EnterEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QCheckBox_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::enterEvent(static_cast<QEvent*>(event));
}

void QCheckBox_HideEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QCheckBox_HideEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::hideEvent(static_cast<QHideEvent*>(event));
}

void QCheckBox_LeaveEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QCheckBox_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::leaveEvent(static_cast<QEvent*>(event));
}

void QCheckBox_MoveEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QCheckBox_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QCheckBox_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QCheckBox_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::setStyleSheet(QString(styleSheet));
}

void QCheckBox_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QCheckBox_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::setVisible(visible != 0);
}

void QCheckBox_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QCheckBox_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::setWindowModified(vbo != 0);
}

void QCheckBox_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QCheckBox_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::setWindowTitle(QString(vqs));
}

void QCheckBox_ShowEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QCheckBox_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::showEvent(static_cast<QShowEvent*>(event));
}

char QCheckBox_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QCheckBox_CloseDefault(void* ptr)
{
	return static_cast<QCheckBox*>(ptr)->QCheckBox::close();
}

void QCheckBox_CloseEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QCheckBox_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::closeEvent(static_cast<QCloseEvent*>(event));
}

void QCheckBox_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QCheckBox_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QCheckBox_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QCheckBox*>(ptr)->focusNextPrevChild(next != 0);
}

char QCheckBox_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QCheckBox*>(ptr)->QCheckBox::focusNextPrevChild(next != 0);
}

char QCheckBox_HasHeightForWidth(void* ptr)
{
	return static_cast<QCheckBox*>(ptr)->hasHeightForWidth();
}

char QCheckBox_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QCheckBox*>(ptr)->QCheckBox::hasHeightForWidth();
}

int QCheckBox_HeightForWidth(void* ptr, int w)
{
	return static_cast<QCheckBox*>(ptr)->heightForWidth(w);
}

int QCheckBox_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QCheckBox*>(ptr)->QCheckBox::heightForWidth(w);
}

void QCheckBox_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "hide");
}

void QCheckBox_HideDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::hide();
}

void QCheckBox_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QCheckBox_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QCheckBox_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QCheckBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QCheckBox_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QCheckBox*>(ptr)->QCheckBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QCheckBox_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "lower");
}

void QCheckBox_LowerDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::lower();
}

void QCheckBox_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QCheckBox_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QCheckBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QCheckBox*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QCheckBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QCheckBox*>(ptr)->QCheckBox::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QCheckBox_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "raise");
}

void QCheckBox_RaiseDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::raise();
}

void QCheckBox_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "repaint");
}

void QCheckBox_RepaintDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::repaint();
}

void QCheckBox_ResizeEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QCheckBox_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QCheckBox_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QCheckBox_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::setDisabled(disable != 0);
}

void QCheckBox_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setFocus");
}

void QCheckBox_SetFocus2Default(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::setFocus();
}

void QCheckBox_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QCheckBox_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::setHidden(hidden != 0);
}

void QCheckBox_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "show");
}

void QCheckBox_ShowDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::show();
}

void QCheckBox_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "showFullScreen");
}

void QCheckBox_ShowFullScreenDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::showFullScreen();
}

void QCheckBox_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "showMaximized");
}

void QCheckBox_ShowMaximizedDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::showMaximized();
}

void QCheckBox_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "showMinimized");
}

void QCheckBox_ShowMinimizedDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::showMinimized();
}

void QCheckBox_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "showNormal");
}

void QCheckBox_ShowNormalDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::showNormal();
}

void QCheckBox_TabletEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QCheckBox_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QCheckBox_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "update");
}

void QCheckBox_UpdateDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::update();
}

void QCheckBox_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "updateMicroFocus");
}

void QCheckBox_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::updateMicroFocus();
}

void QCheckBox_WheelEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QCheckBox_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QCheckBox_ChildEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QCheckBox_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QCheckBox*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QCheckBox_CustomEvent(void* ptr, void* event)
{
	static_cast<QCheckBox*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QCheckBox_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "deleteLater");
}

void QCheckBox_DeleteLaterDefault(void* ptr)
{
	static_cast<QCheckBox*>(ptr)->QCheckBox::deleteLater();
}

void QCheckBox_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QCheckBox*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QCheckBox_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QCheckBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QCheckBox_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QCheckBox*>(ptr)->QCheckBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QCheckBox_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QCheckBox*>(ptr)->metaObject());
}

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

class MyQColorDialog: public QColorDialog
{
public:
	MyQColorDialog(QWidget *parent) : QColorDialog(parent) {};
	MyQColorDialog(const QColor &initial, QWidget *parent) : QColorDialog(initial, parent) {};
	void changeEvent(QEvent * e) { callbackQColorDialog_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) { callbackQColorDialog_SetVisible(this, visible); };
	void accept() { callbackQColorDialog_Accept(this); };
	void closeEvent(QCloseEvent * e) { callbackQColorDialog_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQColorDialog_ContextMenuEvent(this, e); };
	int exec() { return callbackQColorDialog_Exec(this); };
	void keyPressEvent(QKeyEvent * e) { callbackQColorDialog_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQColorDialog_MinimumSizeHint(const_cast<MyQColorDialog*>(this))); };
	void reject() { callbackQColorDialog_Reject(this); };
	void resizeEvent(QResizeEvent * vqr) { callbackQColorDialog_ResizeEvent(this, vqr); };
	void showEvent(QShowEvent * event) { callbackQColorDialog_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQColorDialog_SizeHint(const_cast<MyQColorDialog*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQColorDialog_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQColorDialog_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQColorDialog_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQColorDialog_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQColorDialog_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQColorDialog_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQColorDialog_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQColorDialog_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQColorDialog_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQColorDialog_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQColorDialog_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQColorDialog_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQColorDialog_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQColorDialog_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setWindowModified(bool vbo) { callbackQColorDialog_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQColorDialog_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQColorDialog_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQColorDialog_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQColorDialog_HasHeightForWidth(const_cast<MyQColorDialog*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQColorDialog_HeightForWidth(const_cast<MyQColorDialog*>(this), w); };
	void hide() { callbackQColorDialog_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQColorDialog_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQColorDialog_InputMethodQuery(const_cast<MyQColorDialog*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQColorDialog_KeyReleaseEvent(this, event); };
	void lower() { callbackQColorDialog_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQColorDialog_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQColorDialog_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQColorDialog_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQColorDialog_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQColorDialog_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQColorDialog_Raise(this); };
	void repaint() { callbackQColorDialog_Repaint(this); };
	void setDisabled(bool disable) { callbackQColorDialog_SetDisabled(this, disable); };
	void setFocus() { callbackQColorDialog_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQColorDialog_SetHidden(this, hidden); };
	void show() { callbackQColorDialog_Show(this); };
	void showFullScreen() { callbackQColorDialog_ShowFullScreen(this); };
	void showMaximized() { callbackQColorDialog_ShowMaximized(this); };
	void showMinimized() { callbackQColorDialog_ShowMinimized(this); };
	void showNormal() { callbackQColorDialog_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQColorDialog_TabletEvent(this, event); };
	void update() { callbackQColorDialog_Update(this); };
	void updateMicroFocus() { callbackQColorDialog_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQColorDialog_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQColorDialog_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQColorDialog_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQColorDialog_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQColorDialog_CustomEvent(this, event); };
	void deleteLater() { callbackQColorDialog_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQColorDialog_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQColorDialog_MetaObject(const_cast<MyQColorDialog*>(this))); };
};

void* QColorDialog_CurrentColor(void* ptr)
{
	return new QColor(static_cast<QColorDialog*>(ptr)->currentColor());
}

long long QColorDialog_Options(void* ptr)
{
	return static_cast<QColorDialog*>(ptr)->options();
}

void QColorDialog_SetCurrentColor(void* ptr, void* color)
{
	static_cast<QColorDialog*>(ptr)->setCurrentColor(*static_cast<QColor*>(color));
}

void QColorDialog_SetOptions(void* ptr, long long options)
{
	static_cast<QColorDialog*>(ptr)->setOptions(static_cast<QColorDialog::ColorDialogOption>(options));
}

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_ChangeEvent(void* ptr, void* e)
{
	static_cast<QColorDialog*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QColorDialog_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::changeEvent(static_cast<QEvent*>(e));
}

void QColorDialog_ConnectColorSelected(void* ptr)
{
	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));
}

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_ConnectCurrentColorChanged(void* ptr)
{
	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));
}

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, char* title, long long options)
{
	return new QColor(QColorDialog::getColor(*static_cast<QColor*>(initial), static_cast<QWidget*>(parent), QString(title), static_cast<QColorDialog::ColorDialogOption>(options)));
}

void QColorDialog_Open(void* ptr, void* receiver, char* member)
{
	static_cast<QColorDialog*>(ptr)->open(static_cast<QObject*>(receiver), const_cast<const char*>(member));
}

void* QColorDialog_SelectedColor(void* ptr)
{
	return new QColor(static_cast<QColorDialog*>(ptr)->selectedColor());
}

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_QColorDialog_SetStandardColor(int index, void* color)
{
	QColorDialog::setStandardColor(index, *static_cast<QColor*>(color));
}

void QColorDialog_SetVisible(void* ptr, char visible)
{
	static_cast<QColorDialog*>(ptr)->setVisible(visible != 0);
}

void QColorDialog_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::setVisible(visible != 0);
}

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_Accept(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "accept");
}

void QColorDialog_AcceptDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::accept();
}

void QColorDialog_CloseEvent(void* ptr, void* e)
{
	static_cast<QColorDialog*>(ptr)->closeEvent(static_cast<QCloseEvent*>(e));
}

void QColorDialog_CloseEventDefault(void* ptr, void* e)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::closeEvent(static_cast<QCloseEvent*>(e));
}

void QColorDialog_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QColorDialog*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QColorDialog_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

int QColorDialog_Exec(void* ptr)
{
	int returnArg;
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "exec", Q_RETURN_ARG(int, returnArg));
	return returnArg;
}

int QColorDialog_ExecDefault(void* ptr)
{
	return static_cast<QColorDialog*>(ptr)->QColorDialog::exec();
}

void QColorDialog_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QColorDialog*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QColorDialog_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void* QColorDialog_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QColorDialog*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QColorDialog_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QColorDialog*>(ptr)->QColorDialog::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QColorDialog_Reject(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "reject");
}

void QColorDialog_RejectDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::reject();
}

void QColorDialog_ResizeEvent(void* ptr, void* vqr)
{
	static_cast<QColorDialog*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QColorDialog_ResizeEventDefault(void* ptr, void* vqr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QColorDialog_ShowEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QColorDialog_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::showEvent(static_cast<QShowEvent*>(event));
}

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

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

void QColorDialog_ActionEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QColorDialog_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::actionEvent(static_cast<QActionEvent*>(event));
}

void QColorDialog_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QColorDialog_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QColorDialog_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QColorDialog_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QColorDialog_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QColorDialog_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QColorDialog_DropEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QColorDialog_DropEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::dropEvent(static_cast<QDropEvent*>(event));
}

void QColorDialog_EnterEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QColorDialog_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::enterEvent(static_cast<QEvent*>(event));
}

void QColorDialog_FocusInEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QColorDialog_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QColorDialog_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QColorDialog_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QColorDialog_HideEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QColorDialog_HideEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::hideEvent(static_cast<QHideEvent*>(event));
}

void QColorDialog_LeaveEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QColorDialog_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::leaveEvent(static_cast<QEvent*>(event));
}

void QColorDialog_MoveEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QColorDialog_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::moveEvent(static_cast<QMoveEvent*>(event));
}

void QColorDialog_PaintEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QColorDialog_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::paintEvent(static_cast<QPaintEvent*>(event));
}

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

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

void QColorDialog_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QColorDialog_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::setStyleSheet(QString(styleSheet));
}

void QColorDialog_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QColorDialog_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::setWindowModified(vbo != 0);
}

void QColorDialog_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QColorDialog_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::setWindowTitle(QString(vqs));
}

char QColorDialog_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QColorDialog_CloseDefault(void* ptr)
{
	return static_cast<QColorDialog*>(ptr)->QColorDialog::close();
}

char QColorDialog_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QColorDialog*>(ptr)->focusNextPrevChild(next != 0);
}

char QColorDialog_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QColorDialog*>(ptr)->QColorDialog::focusNextPrevChild(next != 0);
}

char QColorDialog_HasHeightForWidth(void* ptr)
{
	return static_cast<QColorDialog*>(ptr)->hasHeightForWidth();
}

char QColorDialog_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QColorDialog*>(ptr)->QColorDialog::hasHeightForWidth();
}

int QColorDialog_HeightForWidth(void* ptr, int w)
{
	return static_cast<QColorDialog*>(ptr)->heightForWidth(w);
}

int QColorDialog_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QColorDialog*>(ptr)->QColorDialog::heightForWidth(w);
}

void QColorDialog_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "hide");
}

void QColorDialog_HideDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::hide();
}

void QColorDialog_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QColorDialog_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QColorDialog_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QColorDialog*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QColorDialog_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QColorDialog*>(ptr)->QColorDialog::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QColorDialog_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QColorDialog_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QColorDialog_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "lower");
}

void QColorDialog_LowerDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::lower();
}

void QColorDialog_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QColorDialog_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QColorDialog_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QColorDialog_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QColorDialog_MousePressEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QColorDialog_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QColorDialog_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QColorDialog_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QColorDialog_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QColorDialog*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QColorDialog_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QColorDialog*>(ptr)->QColorDialog::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QColorDialog_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "raise");
}

void QColorDialog_RaiseDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::raise();
}

void QColorDialog_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "repaint");
}

void QColorDialog_RepaintDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::repaint();
}

void QColorDialog_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QColorDialog_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::setDisabled(disable != 0);
}

void QColorDialog_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "setFocus");
}

void QColorDialog_SetFocus2Default(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::setFocus();
}

void QColorDialog_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QColorDialog_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::setHidden(hidden != 0);
}

void QColorDialog_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "show");
}

void QColorDialog_ShowDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::show();
}

void QColorDialog_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "showFullScreen");
}

void QColorDialog_ShowFullScreenDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::showFullScreen();
}

void QColorDialog_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "showMaximized");
}

void QColorDialog_ShowMaximizedDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::showMaximized();
}

void QColorDialog_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "showMinimized");
}

void QColorDialog_ShowMinimizedDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::showMinimized();
}

void QColorDialog_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "showNormal");
}

void QColorDialog_ShowNormalDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::showNormal();
}

void QColorDialog_TabletEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QColorDialog_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QColorDialog_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "update");
}

void QColorDialog_UpdateDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::update();
}

void QColorDialog_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "updateMicroFocus");
}

void QColorDialog_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::updateMicroFocus();
}

void QColorDialog_WheelEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QColorDialog_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QColorDialog_TimerEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QColorDialog_ChildEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QColorDialog_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QColorDialog*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QColorDialog_CustomEvent(void* ptr, void* event)
{
	static_cast<QColorDialog*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QColorDialog_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "deleteLater");
}

void QColorDialog_DeleteLaterDefault(void* ptr)
{
	static_cast<QColorDialog*>(ptr)->QColorDialog::deleteLater();
}

void QColorDialog_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QColorDialog*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void* QColorDialog_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QColorDialog*>(ptr)->metaObject());
}

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

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));
}

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();
}

class MyQColumnView: public QColumnView
{
public:
	MyQColumnView(QWidget *parent) : QColumnView(parent) {};
	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<MyQColumnView*>(this)); };
	QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQColumnView_IndexAt(const_cast<MyQColumnView*>(this), const_cast<QPoint*>(&point))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQColumnView_IsIndexHidden(const_cast<MyQColumnView*>(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) { callbackQColumnView_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) { callbackQColumnView_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) { callbackQColumnView_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) { callbackQColumnView_SetSelectionModel(this, newSelectionModel); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQColumnView_SizeHint(const_cast<MyQColumnView*>(this))); };
	void Signal_UpdatePreviewWidget(const QModelIndex & index) { callbackQColumnView_UpdatePreviewWidget(this, const_cast<QModelIndex*>(&index)); };
	int verticalOffset() const { return callbackQColumnView_VerticalOffset(const_cast<MyQColumnView*>(this)); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQColumnView_VisualRect(const_cast<MyQColumnView*>(this), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQColumnView_VisualRegionForSelection(const_cast<MyQColumnView*>(this), const_cast<QItemSelection*>(&selection))); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQColumnView_DragLeaveEvent(this, event); };
	bool viewportEvent(QEvent * event) { return callbackQColumnView_ViewportEvent(this, event) != 0; };
	void clearSelection() { callbackQColumnView_ClearSelection(this); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQColumnView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQColumnView_CommitData(this, editor); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQColumnView_DragEnterEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQColumnView_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQColumnView_DropEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQColumnView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQColumnView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQColumnView_EditorDestroyed(this, editor); };
	void focusInEvent(QFocusEvent * event) { callbackQColumnView_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQColumnView_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQColumnView_FocusOutEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQColumnView_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQColumnView_InputMethodQuery(const_cast<MyQColumnView*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQColumnView_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { callbackQColumnView_KeyboardSearch(this, const_cast<char*>(search.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQColumnView_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQColumnView_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQColumnView_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQColumnView_MouseReleaseEvent(this, event); };
	void reset() { callbackQColumnView_Reset(this); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQColumnView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollToBottom() { callbackQColumnView_ScrollToBottom(this); };
	void scrollToTop() { callbackQColumnView_ScrollToTop(this); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQColumnView_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>(callbackQColumnView_SelectionCommand(const_cast<MyQColumnView*>(this), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQColumnView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	int sizeHintForColumn(int column) const { return callbackQColumnView_SizeHintForColumn(const_cast<MyQColumnView*>(this), column); };
	int sizeHintForRow(int row) const { return callbackQColumnView_SizeHintForRow(const_cast<MyQColumnView*>(this), row); };
	void startDrag(Qt::DropActions supportedActions) { callbackQColumnView_StartDrag(this, supportedActions); };
	void update(const QModelIndex & index) { callbackQColumnView_Update(this, const_cast<QModelIndex*>(&index)); };
	void updateGeometries() { callbackQColumnView_UpdateGeometries(this); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQColumnView_ViewOptions(const_cast<MyQColumnView*>(this))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQColumnView_ViewportSizeHint(const_cast<MyQColumnView*>(this))); };
	void paintEvent(QPaintEvent * event) { callbackQColumnView_PaintEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQColumnView_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQColumnView_MinimumSizeHint(const_cast<MyQColumnView*>(this))); };
	void setupViewport(QWidget * viewport) { callbackQColumnView_SetupViewport(this, viewport); };
	void wheelEvent(QWheelEvent * e) { callbackQColumnView_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQColumnView_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQColumnView_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQColumnView_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQColumnView_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQColumnView_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQColumnView_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQColumnView_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQColumnView_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQColumnView_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQColumnView_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQColumnView_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQColumnView_ShowEvent(this, event); };
	bool close() { return callbackQColumnView_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQColumnView_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQColumnView_HasHeightForWidth(const_cast<MyQColumnView*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQColumnView_HeightForWidth(const_cast<MyQColumnView*>(this), w); };
	void hide() { callbackQColumnView_Hide(this); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQColumnView_KeyReleaseEvent(this, event); };
	void lower() { callbackQColumnView_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQColumnView_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQColumnView_Raise(this); };
	void repaint() { callbackQColumnView_Repaint(this); };
	void setDisabled(bool disable) { callbackQColumnView_SetDisabled(this, disable); };
	void setFocus() { callbackQColumnView_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQColumnView_SetHidden(this, hidden); };
	void show() { callbackQColumnView_Show(this); };
	void showFullScreen() { callbackQColumnView_ShowFullScreen(this); };
	void showMaximized() { callbackQColumnView_ShowMaximized(this); };
	void showMinimized() { callbackQColumnView_ShowMinimized(this); };
	void showNormal() { callbackQColumnView_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQColumnView_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQColumnView_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQColumnView_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQColumnView_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQColumnView_CustomEvent(this, event); };
	void deleteLater() { callbackQColumnView_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQColumnView_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQColumnView_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQColumnView_MetaObject(const_cast<MyQColumnView*>(this))); };
};

char QColumnView_ResizeGripsVisible(void* ptr)
{
	return static_cast<QColumnView*>(ptr)->resizeGripsVisible();
}

void QColumnView_SetResizeGripsVisible(void* ptr, char visible)
{
	static_cast<QColumnView*>(ptr)->setResizeGripsVisible(visible != 0);
}

void* QColumnView_NewQColumnView(void* parent)
{
	return new MyQColumnView(static_cast<QWidget*>(parent));
}

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();
}

void QColumnView_ResizeEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QColumnView_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::resizeEvent(static_cast<QResizeEvent*>(event));
}

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_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QColumnView*>(ptr)->scrollContentsBy(dx, dy);
}

void QColumnView_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QColumnView*>(ptr)->QColumnView::scrollContentsBy(dx, dy);
}

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_SetModel(void* ptr, void* model)
{
	static_cast<QColumnView*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}

void QColumnView_SetModelDefault(void* ptr, void* model)
{
	static_cast<QColumnView*>(ptr)->QColumnView::setModel(static_cast<QAbstractItemModel*>(model));
}

void QColumnView_SetPreviewWidget(void* ptr, void* widget)
{
	static_cast<QColumnView*>(ptr)->setPreviewWidget(static_cast<QWidget*>(widget));
}

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_SetSelectionModel(void* ptr, void* newSelectionModel)
{
	static_cast<QColumnView*>(ptr)->setSelectionModel(static_cast<QItemSelectionModel*>(newSelectionModel));
}

void QColumnView_SetSelectionModelDefault(void* ptr, void* newSelectionModel)
{
	static_cast<QColumnView*>(ptr)->QColumnView::setSelectionModel(static_cast<QItemSelectionModel*>(newSelectionModel));
}

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

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

void QColumnView_ConnectUpdatePreviewWidget(void* ptr)
{
	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));
}

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_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QColumnView_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

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

char QColumnView_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QColumnView*>(ptr)->QColumnView::viewportEvent(static_cast<QEvent*>(event));
}

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

void QColumnView_ClearSelectionDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::clearSelection();
}

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

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

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

void QColumnView_CommitDataDefault(void* ptr, void* editor)
{
	static_cast<QColumnView*>(ptr)->QColumnView::commitData(static_cast<QWidget*>(editor));
}

void QColumnView_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QColumnView_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QColumnView_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QColumnView_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QColumnView_DropEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QColumnView_DropEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::dropEvent(static_cast<QDropEvent*>(event));
}

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

void QColumnView_EditDefault(void* ptr, void* index)
{
	static_cast<QColumnView*>(ptr)->QColumnView::edit(*static_cast<QModelIndex*>(index));
}

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

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

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

void QColumnView_EditorDestroyedDefault(void* ptr, void* editor)
{
	static_cast<QColumnView*>(ptr)->QColumnView::editorDestroyed(static_cast<QObject*>(editor));
}

void QColumnView_FocusInEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QColumnView_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QColumnView_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QColumnView*>(ptr)->focusNextPrevChild(next != 0);
}

char QColumnView_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QColumnView*>(ptr)->QColumnView::focusNextPrevChild(next != 0);
}

void QColumnView_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QColumnView_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QColumnView_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QColumnView_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QColumnView_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QColumnView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QColumnView_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QColumnView*>(ptr)->QColumnView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QColumnView_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QColumnView_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QColumnView_KeyboardSearch(void* ptr, char* search)
{
	static_cast<QColumnView*>(ptr)->keyboardSearch(QString(search));
}

void QColumnView_KeyboardSearchDefault(void* ptr, char* search)
{
	static_cast<QColumnView*>(ptr)->QColumnView::keyboardSearch(QString(search));
}

void QColumnView_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QColumnView_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QColumnView_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QColumnView_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QColumnView_MousePressEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QColumnView_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QColumnView_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QColumnView_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

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

void QColumnView_ResetDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::reset();
}

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

void QColumnView_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QColumnView*>(ptr)->QColumnView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
}

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

void QColumnView_ScrollToBottomDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::scrollToBottom();
}

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

void QColumnView_ScrollToTopDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::scrollToTop();
}

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

void QColumnView_SelectionChangedDefault(void* ptr, void* selected, void* deselected)
{
	static_cast<QColumnView*>(ptr)->QColumnView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

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

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

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

void QColumnView_SetCurrentIndexDefault(void* ptr, void* index)
{
	static_cast<QColumnView*>(ptr)->QColumnView::setCurrentIndex(*static_cast<QModelIndex*>(index));
}

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

int QColumnView_SizeHintForColumnDefault(void* ptr, int column)
{
	return static_cast<QColumnView*>(ptr)->QColumnView::sizeHintForColumn(column);
}

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

int QColumnView_SizeHintForRowDefault(void* ptr, int row)
{
	return static_cast<QColumnView*>(ptr)->QColumnView::sizeHintForRow(row);
}

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

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

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

void QColumnView_UpdateDefault(void* ptr, void* index)
{
	static_cast<QColumnView*>(ptr)->QColumnView::update(*static_cast<QModelIndex*>(index));
}

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

void QColumnView_UpdateGeometriesDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::updateGeometries();
}

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

void* QColumnView_ViewOptionsDefault(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QColumnView*>(ptr)->QColumnView::viewOptions());
}

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

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

void QColumnView_PaintEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QColumnView_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::paintEvent(static_cast<QPaintEvent*>(event));
}

void QColumnView_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QColumnView*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QColumnView_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QColumnView*>(ptr)->QColumnView::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void* QColumnView_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QColumnView*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QColumnView_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QColumnView*>(ptr)->QColumnView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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

void QColumnView_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QColumnView*>(ptr)->QColumnView::setupViewport(static_cast<QWidget*>(viewport));
}

void QColumnView_WheelEvent(void* ptr, void* e)
{
	static_cast<QColumnView*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QColumnView_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QColumnView*>(ptr)->QColumnView::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QColumnView_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QColumnView*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QColumnView_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QColumnView*>(ptr)->QColumnView::changeEvent(static_cast<QEvent*>(ev));
}

void QColumnView_ActionEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QColumnView_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::actionEvent(static_cast<QActionEvent*>(event));
}

void QColumnView_EnterEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QColumnView_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::enterEvent(static_cast<QEvent*>(event));
}

void QColumnView_HideEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QColumnView_HideEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::hideEvent(static_cast<QHideEvent*>(event));
}

void QColumnView_LeaveEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QColumnView_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::leaveEvent(static_cast<QEvent*>(event));
}

void QColumnView_MoveEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QColumnView_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QColumnView_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QColumnView_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QColumnView*>(ptr)->QColumnView::setStyleSheet(QString(styleSheet));
}

void QColumnView_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QColumnView_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QColumnView*>(ptr)->QColumnView::setVisible(visible != 0);
}

void QColumnView_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QColumnView_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QColumnView*>(ptr)->QColumnView::setWindowModified(vbo != 0);
}

void QColumnView_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QColumnView_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QColumnView*>(ptr)->QColumnView::setWindowTitle(QString(vqs));
}

void QColumnView_ShowEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QColumnView_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::showEvent(static_cast<QShowEvent*>(event));
}

char QColumnView_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QColumnView_CloseDefault(void* ptr)
{
	return static_cast<QColumnView*>(ptr)->QColumnView::close();
}

void QColumnView_CloseEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QColumnView_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::closeEvent(static_cast<QCloseEvent*>(event));
}

char QColumnView_HasHeightForWidth(void* ptr)
{
	return static_cast<QColumnView*>(ptr)->hasHeightForWidth();
}

char QColumnView_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QColumnView*>(ptr)->QColumnView::hasHeightForWidth();
}

int QColumnView_HeightForWidth(void* ptr, int w)
{
	return static_cast<QColumnView*>(ptr)->heightForWidth(w);
}

int QColumnView_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QColumnView*>(ptr)->QColumnView::heightForWidth(w);
}

void QColumnView_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "hide");
}

void QColumnView_HideDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::hide();
}

void QColumnView_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QColumnView_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QColumnView_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "lower");
}

void QColumnView_LowerDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::lower();
}

char QColumnView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QColumnView*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QColumnView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QColumnView*>(ptr)->QColumnView::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QColumnView_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "raise");
}

void QColumnView_RaiseDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::raise();
}

void QColumnView_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "repaint");
}

void QColumnView_RepaintDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::repaint();
}

void QColumnView_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QColumnView_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QColumnView*>(ptr)->QColumnView::setDisabled(disable != 0);
}

void QColumnView_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "setFocus");
}

void QColumnView_SetFocus2Default(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::setFocus();
}

void QColumnView_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QColumnView_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QColumnView*>(ptr)->QColumnView::setHidden(hidden != 0);
}

void QColumnView_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "show");
}

void QColumnView_ShowDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::show();
}

void QColumnView_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "showFullScreen");
}

void QColumnView_ShowFullScreenDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::showFullScreen();
}

void QColumnView_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "showMaximized");
}

void QColumnView_ShowMaximizedDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::showMaximized();
}

void QColumnView_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "showMinimized");
}

void QColumnView_ShowMinimizedDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::showMinimized();
}

void QColumnView_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "showNormal");
}

void QColumnView_ShowNormalDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::showNormal();
}

void QColumnView_TabletEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QColumnView_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->QColumnView::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QColumnView_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "updateMicroFocus");
}

void QColumnView_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::updateMicroFocus();
}

void QColumnView_ChildEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QColumnView_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QColumnView*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QColumnView_CustomEvent(void* ptr, void* event)
{
	static_cast<QColumnView*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QColumnView_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "deleteLater");
}

void QColumnView_DeleteLaterDefault(void* ptr)
{
	static_cast<QColumnView*>(ptr)->QColumnView::deleteLater();
}

void QColumnView_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QColumnView*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QColumnView_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QColumnView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QColumnView_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QColumnView*>(ptr)->QColumnView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QColumnView_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QColumnView*>(ptr)->metaObject());
}

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

class MyQComboBox: public QComboBox
{
public:
	MyQComboBox(QWidget *parent) : QComboBox(parent) {};
	void setCurrentIndex(int index) { callbackQComboBox_SetCurrentIndex(this, index); };
	void setCurrentText(const QString & text) { callbackQComboBox_SetCurrentText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_Activated2(const QString & text) { callbackQComboBox_Activated2(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_Activated(int index) { callbackQComboBox_Activated(this, index); };
	void changeEvent(QEvent * e) { callbackQComboBox_ChangeEvent(this, e); };
	void clear() { callbackQComboBox_Clear(this); };
	void clearEditText() { callbackQComboBox_ClearEditText(this); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQComboBox_ContextMenuEvent(this, e); };
	void Signal_CurrentIndexChanged2(const QString & text) { callbackQComboBox_CurrentIndexChanged2(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_CurrentIndexChanged(int index) { callbackQComboBox_CurrentIndexChanged(this, index); };
	void Signal_CurrentTextChanged(const QString & text) { callbackQComboBox_CurrentTextChanged(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_EditTextChanged(const QString & text) { callbackQComboBox_EditTextChanged(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void focusInEvent(QFocusEvent * e) { callbackQComboBox_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQComboBox_FocusOutEvent(this, e); };
	void hideEvent(QHideEvent * e) { callbackQComboBox_HideEvent(this, e); };
	void hidePopup() { callbackQComboBox_HidePopup(this); };
	void Signal_Highlighted2(const QString & text) { callbackQComboBox_Highlighted2(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_Highlighted(int index) { callbackQComboBox_Highlighted(this, index); };
	void inputMethodEvent(QInputMethodEvent * e) { callbackQComboBox_InputMethodEvent(this, e); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQComboBox_InputMethodQuery(const_cast<MyQComboBox*>(this), query)); };
	void keyPressEvent(QKeyEvent * e) { callbackQComboBox_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQComboBox_KeyReleaseEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQComboBox_MinimumSizeHint(const_cast<MyQComboBox*>(this))); };
	void mousePressEvent(QMouseEvent * e) { callbackQComboBox_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQComboBox_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQComboBox_PaintEvent(this, e); };
	void resizeEvent(QResizeEvent * e) { callbackQComboBox_ResizeEvent(this, e); };
	void setEditText(const QString & text) { callbackQComboBox_SetEditText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * e) { callbackQComboBox_ShowEvent(this, e); };
	void showPopup() { callbackQComboBox_ShowPopup(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQComboBox_SizeHint(const_cast<MyQComboBox*>(this))); };
	void wheelEvent(QWheelEvent * e) { callbackQComboBox_WheelEvent(this, e); };
	void actionEvent(QActionEvent * event) { callbackQComboBox_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQComboBox_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQComboBox_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQComboBox_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQComboBox_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQComboBox_EnterEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQComboBox_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQComboBox_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQComboBox_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQComboBox_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQComboBox_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQComboBox_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQComboBox_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQComboBox_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQComboBox_CloseEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQComboBox_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQComboBox_HasHeightForWidth(const_cast<MyQComboBox*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQComboBox_HeightForWidth(const_cast<MyQComboBox*>(this), w); };
	void hide() { callbackQComboBox_Hide(this); };
	void lower() { callbackQComboBox_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQComboBox_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQComboBox_MouseMoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQComboBox_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQComboBox_Raise(this); };
	void repaint() { callbackQComboBox_Repaint(this); };
	void setDisabled(bool disable) { callbackQComboBox_SetDisabled(this, disable); };
	void setFocus() { callbackQComboBox_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQComboBox_SetHidden(this, hidden); };
	void show() { callbackQComboBox_Show(this); };
	void showFullScreen() { callbackQComboBox_ShowFullScreen(this); };
	void showMaximized() { callbackQComboBox_ShowMaximized(this); };
	void showMinimized() { callbackQComboBox_ShowMinimized(this); };
	void showNormal() { callbackQComboBox_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQComboBox_TabletEvent(this, event); };
	void update() { callbackQComboBox_Update(this); };
	void updateMicroFocus() { callbackQComboBox_UpdateMicroFocus(this); };
	void timerEvent(QTimerEvent * event) { callbackQComboBox_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQComboBox_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQComboBox_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQComboBox_CustomEvent(this, event); };
	void deleteLater() { callbackQComboBox_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQComboBox_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQComboBox_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQComboBox_MetaObject(const_cast<MyQComboBox*>(this))); };
};

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();
}

char* QComboBox_CurrentText(void* ptr)
{
	return const_cast<char*>(static_cast<QComboBox*>(ptr)->currentText().toUtf8().prepend("WHITESPACE").constData()+10);
}

char QComboBox_DuplicatesEnabled(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->duplicatesEnabled();
}

char QComboBox_HasFrame(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->hasFrame();
}

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

long long QComboBox_InsertPolicy(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->insertPolicy();
}

char QComboBox_IsEditable(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->isEditable();
}

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();
}

int QComboBox_ModelColumn(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->modelColumn();
}

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_SetCurrentText(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setCurrentText", Q_ARG(QString, QString(text)));
}

void QComboBox_SetDuplicatesEnabled(void* ptr, char enable)
{
	static_cast<QComboBox*>(ptr)->setDuplicatesEnabled(enable != 0);
}

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_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_SetModelColumn(void* ptr, int visibleColumn)
{
	static_cast<QComboBox*>(ptr)->setModelColumn(visibleColumn);
}

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));
}

long long QComboBox_SizeAdjustPolicy(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->sizeAdjustPolicy();
}

void* QComboBox_NewQComboBox(void* parent)
{
	return new MyQComboBox(static_cast<QWidget*>(parent));
}

void QComboBox_ConnectActivated2(void* ptr)
{
	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));
}

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, char* text)
{
	static_cast<QComboBox*>(ptr)->activated(QString(text));
}

void QComboBox_ConnectActivated(void* ptr)
{
	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));
}

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_AddItem2(void* ptr, void* icon, char* text, void* userData)
{
	static_cast<QComboBox*>(ptr)->addItem(*static_cast<QIcon*>(icon), QString(text), *static_cast<QVariant*>(userData));
}

void QComboBox_AddItem(void* ptr, char* text, void* userData)
{
	static_cast<QComboBox*>(ptr)->addItem(QString(text), *static_cast<QVariant*>(userData));
}

void QComboBox_AddItems(void* ptr, char* texts)
{
	static_cast<QComboBox*>(ptr)->addItems(QString(texts).split("|", QString::SkipEmptyParts));
}

void QComboBox_ChangeEvent(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QComboBox_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::changeEvent(static_cast<QEvent*>(e));
}

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

void QComboBox_ClearEditText(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "clearEditText");
}

void* QComboBox_Completer(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->completer();
}

void QComboBox_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QComboBox_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QComboBox_ConnectCurrentIndexChanged2(void* ptr)
{
	QObject::connect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::currentIndexChanged), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(const QString &)>(&MyQComboBox::Signal_CurrentIndexChanged2));
}

void QComboBox_DisconnectCurrentIndexChanged2(void* ptr)
{
	QObject::disconnect(static_cast<QComboBox*>(ptr), static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::currentIndexChanged), static_cast<MyQComboBox*>(ptr), static_cast<void (MyQComboBox::*)(const QString &)>(&MyQComboBox::Signal_CurrentIndexChanged2));
}

void QComboBox_CurrentIndexChanged2(void* ptr, char* text)
{
	static_cast<QComboBox*>(ptr)->currentIndexChanged(QString(text));
}

void QComboBox_ConnectCurrentIndexChanged(void* ptr)
{
	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));
}

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);
}

void QComboBox_ConnectCurrentTextChanged(void* ptr)
{
	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));
}

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, char* text)
{
	static_cast<QComboBox*>(ptr)->currentTextChanged(QString(text));
}

void QComboBox_ConnectEditTextChanged(void* ptr)
{
	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));
}

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, char* text)
{
	static_cast<QComboBox*>(ptr)->editTextChanged(QString(text));
}

char QComboBox_Event(void* ptr, void* event)
{
	return static_cast<QComboBox*>(ptr)->event(static_cast<QEvent*>(event));
}

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, char* text, long long flags)
{
	return static_cast<QComboBox*>(ptr)->findText(QString(text), static_cast<Qt::MatchFlag>(flags));
}

void QComboBox_FocusInEvent(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(e));
}

void QComboBox_FocusInEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::focusInEvent(static_cast<QFocusEvent*>(e));
}

void QComboBox_FocusOutEvent(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QComboBox_FocusOutEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QComboBox_HideEvent(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->hideEvent(static_cast<QHideEvent*>(e));
}

void QComboBox_HideEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::hideEvent(static_cast<QHideEvent*>(e));
}

void QComboBox_HidePopup(void* ptr)
{
	static_cast<QComboBox*>(ptr)->hidePopup();
}

void QComboBox_HidePopupDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::hidePopup();
}

void QComboBox_ConnectHighlighted2(void* ptr)
{
	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));
}

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, char* text)
{
	static_cast<QComboBox*>(ptr)->highlighted(QString(text));
}

void QComboBox_ConnectHighlighted(void* ptr)
{
	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));
}

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_InitStyleOption(void* ptr, void* option)
{
	static_cast<QComboBox*>(ptr)->initStyleOption(static_cast<QStyleOptionComboBox*>(option));
}

void QComboBox_InputMethodEvent(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(e));
}

void QComboBox_InputMethodEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::inputMethodEvent(static_cast<QInputMethodEvent*>(e));
}

void* QComboBox_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QComboBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QComboBox_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QComboBox*>(ptr)->QComboBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QComboBox_InsertItem2(void* ptr, int index, void* icon, char* text, void* userData)
{
	static_cast<QComboBox*>(ptr)->insertItem(index, *static_cast<QIcon*>(icon), QString(text), *static_cast<QVariant*>(userData));
}

void QComboBox_InsertItem(void* ptr, int index, char* text, void* userData)
{
	static_cast<QComboBox*>(ptr)->insertItem(index, QString(text), *static_cast<QVariant*>(userData));
}

void QComboBox_InsertItems(void* ptr, int index, char* list)
{
	static_cast<QComboBox*>(ptr)->insertItems(index, QString(list).split("|", QString::SkipEmptyParts));
}

void QComboBox_InsertSeparator(void* ptr, int index)
{
	static_cast<QComboBox*>(ptr)->insertSeparator(index);
}

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));
}

char* QComboBox_ItemText(void* ptr, int index)
{
	return const_cast<char*>(static_cast<QComboBox*>(ptr)->itemText(index).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QComboBox_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QComboBox_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QComboBox_KeyReleaseEvent(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QComboBox_KeyReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void* QComboBox_LineEdit(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->lineEdit();
}

void* QComboBox_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QComboBox*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QComboBox_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QComboBox*>(ptr)->QComboBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QComboBox_Model(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->model();
}

void QComboBox_MousePressEvent(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QComboBox_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QComboBox_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QComboBox_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

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

void QComboBox_PaintEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::paintEvent(static_cast<QPaintEvent*>(e));
}

void QComboBox_RemoveItem(void* ptr, int index)
{
	static_cast<QComboBox*>(ptr)->removeItem(index);
}

void QComboBox_ResizeEvent(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(e));
}

void QComboBox_ResizeEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::resizeEvent(static_cast<QResizeEvent*>(e));
}

void* QComboBox_RootModelIndex(void* ptr)
{
	return new QModelIndex(static_cast<QComboBox*>(ptr)->rootModelIndex());
}

void QComboBox_SetEditText(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setEditText", Q_ARG(QString, QString(text)));
}

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, char* text)
{
	static_cast<QComboBox*>(ptr)->setItemText(index, QString(text));
}

void QComboBox_SetLineEdit(void* ptr, void* edit)
{
	static_cast<QComboBox*>(ptr)->setLineEdit(static_cast<QLineEdit*>(edit));
}

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

void QComboBox_SetRootModelIndex(void* ptr, void* index)
{
	static_cast<QComboBox*>(ptr)->setRootModelIndex(*static_cast<QModelIndex*>(index));
}

void QComboBox_SetView(void* ptr, void* itemView)
{
	static_cast<QComboBox*>(ptr)->setView(static_cast<QAbstractItemView*>(itemView));
}

void QComboBox_ShowEvent(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->showEvent(static_cast<QShowEvent*>(e));
}

void QComboBox_ShowEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::showEvent(static_cast<QShowEvent*>(e));
}

void QComboBox_ShowPopup(void* ptr)
{
	static_cast<QComboBox*>(ptr)->showPopup();
}

void QComboBox_ShowPopupDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::showPopup();
}

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

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

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_WheelEvent(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QComboBox_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QComboBox*>(ptr)->QComboBox::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QComboBox_DestroyQComboBox(void* ptr)
{
	static_cast<QComboBox*>(ptr)->~QComboBox();
}

void QComboBox_ActionEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QComboBox_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->QComboBox::actionEvent(static_cast<QActionEvent*>(event));
}

void QComboBox_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QComboBox_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->QComboBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QComboBox_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QComboBox_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->QComboBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QComboBox_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QComboBox_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->QComboBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QComboBox_DropEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QComboBox_DropEventDefault(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->QComboBox::dropEvent(static_cast<QDropEvent*>(event));
}

void QComboBox_EnterEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QComboBox_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->QComboBox::enterEvent(static_cast<QEvent*>(event));
}

void QComboBox_LeaveEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QComboBox_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->QComboBox::leaveEvent(static_cast<QEvent*>(event));
}

void QComboBox_MoveEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QComboBox_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->QComboBox::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QComboBox_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QComboBox_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QComboBox*>(ptr)->QComboBox::setStyleSheet(QString(styleSheet));
}

void QComboBox_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QComboBox_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QComboBox*>(ptr)->QComboBox::setVisible(visible != 0);
}

void QComboBox_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QComboBox_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QComboBox*>(ptr)->QComboBox::setWindowModified(vbo != 0);
}

void QComboBox_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QComboBox_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QComboBox*>(ptr)->QComboBox::setWindowTitle(QString(vqs));
}

char QComboBox_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QComboBox_CloseDefault(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->QComboBox::close();
}

void QComboBox_CloseEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QComboBox_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->QComboBox::closeEvent(static_cast<QCloseEvent*>(event));
}

char QComboBox_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QComboBox*>(ptr)->focusNextPrevChild(next != 0);
}

char QComboBox_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QComboBox*>(ptr)->QComboBox::focusNextPrevChild(next != 0);
}

char QComboBox_HasHeightForWidth(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->hasHeightForWidth();
}

char QComboBox_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QComboBox*>(ptr)->QComboBox::hasHeightForWidth();
}

int QComboBox_HeightForWidth(void* ptr, int w)
{
	return static_cast<QComboBox*>(ptr)->heightForWidth(w);
}

int QComboBox_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QComboBox*>(ptr)->QComboBox::heightForWidth(w);
}

void QComboBox_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "hide");
}

void QComboBox_HideDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::hide();
}

void QComboBox_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "lower");
}

void QComboBox_LowerDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::lower();
}

void QComboBox_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QComboBox_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->QComboBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QComboBox_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QComboBox_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->QComboBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

char QComboBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QComboBox*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QComboBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QComboBox*>(ptr)->QComboBox::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QComboBox_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "raise");
}

void QComboBox_RaiseDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::raise();
}

void QComboBox_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "repaint");
}

void QComboBox_RepaintDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::repaint();
}

void QComboBox_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QComboBox_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QComboBox*>(ptr)->QComboBox::setDisabled(disable != 0);
}

void QComboBox_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setFocus");
}

void QComboBox_SetFocus2Default(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::setFocus();
}

void QComboBox_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QComboBox_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QComboBox*>(ptr)->QComboBox::setHidden(hidden != 0);
}

void QComboBox_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "show");
}

void QComboBox_ShowDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::show();
}

void QComboBox_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "showFullScreen");
}

void QComboBox_ShowFullScreenDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::showFullScreen();
}

void QComboBox_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "showMaximized");
}

void QComboBox_ShowMaximizedDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::showMaximized();
}

void QComboBox_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "showMinimized");
}

void QComboBox_ShowMinimizedDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::showMinimized();
}

void QComboBox_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "showNormal");
}

void QComboBox_ShowNormalDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::showNormal();
}

void QComboBox_TabletEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QComboBox_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->QComboBox::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QComboBox_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "update");
}

void QComboBox_UpdateDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::update();
}

void QComboBox_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "updateMicroFocus");
}

void QComboBox_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::updateMicroFocus();
}

void QComboBox_TimerEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QComboBox_ChildEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QComboBox_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QComboBox*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QComboBox_CustomEvent(void* ptr, void* event)
{
	static_cast<QComboBox*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QComboBox_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "deleteLater");
}

void QComboBox_DeleteLaterDefault(void* ptr)
{
	static_cast<QComboBox*>(ptr)->QComboBox::deleteLater();
}

void QComboBox_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QComboBox*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QComboBox_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QComboBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QComboBox_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QComboBox*>(ptr)->QComboBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QComboBox_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QComboBox*>(ptr)->metaObject());
}

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

class MyQCommandLinkButton: public QCommandLinkButton
{
public:
	MyQCommandLinkButton(QWidget *parent) : QCommandLinkButton(parent) {};
	MyQCommandLinkButton(const QString &text, QWidget *parent) : QCommandLinkButton(text, parent) {};
	MyQCommandLinkButton(const QString &text, const QString &description, QWidget *parent) : QCommandLinkButton(text, description, parent) {};
	int heightForWidth(int width) const { return callbackQCommandLinkButton_HeightForWidth(const_cast<MyQCommandLinkButton*>(this), width); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQCommandLinkButton_MinimumSizeHint(const_cast<MyQCommandLinkButton*>(this))); };
	void paintEvent(QPaintEvent * vqp) { callbackQCommandLinkButton_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQCommandLinkButton_SizeHint(const_cast<MyQCommandLinkButton*>(this))); };
	void focusInEvent(QFocusEvent * e) { callbackQCommandLinkButton_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQCommandLinkButton_FocusOutEvent(this, e); };
	bool hitButton(const QPoint & pos) const { return callbackQCommandLinkButton_HitButton(const_cast<MyQCommandLinkButton*>(this), const_cast<QPoint*>(&pos)) != 0; };
	void keyPressEvent(QKeyEvent * e) { callbackQCommandLinkButton_KeyPressEvent(this, e); };
	void showMenu() { callbackQCommandLinkButton_ShowMenu(this); };
	void setChecked(bool vbo) { callbackQCommandLinkButton_SetChecked(this, vbo); };
	void setIconSize(const QSize & size) { callbackQCommandLinkButton_SetIconSize(this, const_cast<QSize*>(&size)); };
	void toggle() { callbackQCommandLinkButton_Toggle(this); };
	void animateClick(int msec) { callbackQCommandLinkButton_AnimateClick(this, msec); };
	void changeEvent(QEvent * e) { callbackQCommandLinkButton_ChangeEvent(this, e); };
	void checkStateSet() { callbackQCommandLinkButton_CheckStateSet(this); };
	void click() { callbackQCommandLinkButton_Click(this); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQCommandLinkButton_KeyReleaseEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQCommandLinkButton_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQCommandLinkButton_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQCommandLinkButton_MouseReleaseEvent(this, e); };
	void nextCheckState() { callbackQCommandLinkButton_NextCheckState(this); };
	void actionEvent(QActionEvent * event) { callbackQCommandLinkButton_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQCommandLinkButton_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQCommandLinkButton_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQCommandLinkButton_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQCommandLinkButton_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQCommandLinkButton_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQCommandLinkButton_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQCommandLinkButton_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQCommandLinkButton_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQCommandLinkButton_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQCommandLinkButton_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQCommandLinkButton_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQCommandLinkButton_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQCommandLinkButton_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQCommandLinkButton_ShowEvent(this, event); };
	bool close() { return callbackQCommandLinkButton_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQCommandLinkButton_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQCommandLinkButton_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQCommandLinkButton_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQCommandLinkButton_HasHeightForWidth(const_cast<MyQCommandLinkButton*>(this)) != 0; };
	void hide() { callbackQCommandLinkButton_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQCommandLinkButton_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQCommandLinkButton_InputMethodQuery(const_cast<MyQCommandLinkButton*>(this), query)); };
	void lower() { callbackQCommandLinkButton_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQCommandLinkButton_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQCommandLinkButton_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQCommandLinkButton_Raise(this); };
	void repaint() { callbackQCommandLinkButton_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQCommandLinkButton_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQCommandLinkButton_SetDisabled(this, disable); };
	void setFocus() { callbackQCommandLinkButton_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQCommandLinkButton_SetHidden(this, hidden); };
	void show() { callbackQCommandLinkButton_Show(this); };
	void showFullScreen() { callbackQCommandLinkButton_ShowFullScreen(this); };
	void showMaximized() { callbackQCommandLinkButton_ShowMaximized(this); };
	void showMinimized() { callbackQCommandLinkButton_ShowMinimized(this); };
	void showNormal() { callbackQCommandLinkButton_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQCommandLinkButton_TabletEvent(this, event); };
	void update() { callbackQCommandLinkButton_Update(this); };
	void updateMicroFocus() { callbackQCommandLinkButton_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQCommandLinkButton_WheelEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQCommandLinkButton_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQCommandLinkButton_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQCommandLinkButton_CustomEvent(this, event); };
	void deleteLater() { callbackQCommandLinkButton_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQCommandLinkButton_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQCommandLinkButton_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCommandLinkButton_MetaObject(const_cast<MyQCommandLinkButton*>(this))); };
};

char* QCommandLinkButton_Description(void* ptr)
{
	return const_cast<char*>(static_cast<QCommandLinkButton*>(ptr)->description().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QCommandLinkButton_SetDescription(void* ptr, char* description)
{
	static_cast<QCommandLinkButton*>(ptr)->setDescription(QString(description));
}

void* QCommandLinkButton_NewQCommandLinkButton(void* parent)
{
	return new MyQCommandLinkButton(static_cast<QWidget*>(parent));
}

void* QCommandLinkButton_NewQCommandLinkButton2(char* text, void* parent)
{
	return new MyQCommandLinkButton(QString(text), static_cast<QWidget*>(parent));
}

void* QCommandLinkButton_NewQCommandLinkButton3(char* text, char* description, void* parent)
{
	return new MyQCommandLinkButton(QString(text), QString(description), static_cast<QWidget*>(parent));
}

char QCommandLinkButton_Event(void* ptr, void* e)
{
	return static_cast<QCommandLinkButton*>(ptr)->event(static_cast<QEvent*>(e));
}

int QCommandLinkButton_HeightForWidth(void* ptr, int width)
{
	return static_cast<QCommandLinkButton*>(ptr)->heightForWidth(width);
}

int QCommandLinkButton_HeightForWidthDefault(void* ptr, int width)
{
	return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::heightForWidth(width);
}

void* QCommandLinkButton_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QCommandLinkButton*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QCommandLinkButton_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QCommandLinkButton_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QCommandLinkButton*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QCommandLinkButton_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::paintEvent(static_cast<QPaintEvent*>(vqp));
}

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

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

void QCommandLinkButton_DestroyQCommandLinkButton(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->~QCommandLinkButton();
}

void QCommandLinkButton_FocusInEvent(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(e));
}

void QCommandLinkButton_FocusInEventDefault(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::focusInEvent(static_cast<QFocusEvent*>(e));
}

void QCommandLinkButton_FocusOutEvent(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QCommandLinkButton_FocusOutEventDefault(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::focusOutEvent(static_cast<QFocusEvent*>(e));
}

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

char QCommandLinkButton_HitButtonDefault(void* ptr, void* pos)
{
	return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::hitButton(*static_cast<QPoint*>(pos));
}

void QCommandLinkButton_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QCommandLinkButton_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QCommandLinkButton_ShowMenu(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "showMenu");
}

void QCommandLinkButton_ShowMenuDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::showMenu();
}

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

void QCommandLinkButton_SetCheckedDefault(void* ptr, char vbo)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setChecked(vbo != 0);
}

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

void QCommandLinkButton_SetIconSizeDefault(void* ptr, void* size)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setIconSize(*static_cast<QSize*>(size));
}

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

void QCommandLinkButton_ToggleDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::toggle();
}

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

void QCommandLinkButton_AnimateClickDefault(void* ptr, int msec)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::animateClick(msec);
}

void QCommandLinkButton_ChangeEvent(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QCommandLinkButton_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::changeEvent(static_cast<QEvent*>(e));
}

void QCommandLinkButton_CheckStateSet(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->checkStateSet();
}

void QCommandLinkButton_CheckStateSetDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::checkStateSet();
}

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

void QCommandLinkButton_ClickDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::click();
}

void QCommandLinkButton_KeyReleaseEvent(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QCommandLinkButton_KeyReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QCommandLinkButton_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QCommandLinkButton_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QCommandLinkButton_MousePressEvent(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QCommandLinkButton_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QCommandLinkButton_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QCommandLinkButton_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QCommandLinkButton_NextCheckState(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->nextCheckState();
}

void QCommandLinkButton_NextCheckStateDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::nextCheckState();
}

void QCommandLinkButton_ActionEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QCommandLinkButton_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::actionEvent(static_cast<QActionEvent*>(event));
}

void QCommandLinkButton_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QCommandLinkButton_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QCommandLinkButton_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QCommandLinkButton_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QCommandLinkButton_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QCommandLinkButton_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QCommandLinkButton_DropEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QCommandLinkButton_DropEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::dropEvent(static_cast<QDropEvent*>(event));
}

void QCommandLinkButton_EnterEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QCommandLinkButton_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::enterEvent(static_cast<QEvent*>(event));
}

void QCommandLinkButton_HideEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QCommandLinkButton_HideEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::hideEvent(static_cast<QHideEvent*>(event));
}

void QCommandLinkButton_LeaveEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QCommandLinkButton_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::leaveEvent(static_cast<QEvent*>(event));
}

void QCommandLinkButton_MoveEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QCommandLinkButton_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QCommandLinkButton_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QCommandLinkButton_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setStyleSheet(QString(styleSheet));
}

void QCommandLinkButton_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QCommandLinkButton_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setVisible(visible != 0);
}

void QCommandLinkButton_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QCommandLinkButton_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setWindowModified(vbo != 0);
}

void QCommandLinkButton_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QCommandLinkButton_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setWindowTitle(QString(vqs));
}

void QCommandLinkButton_ShowEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QCommandLinkButton_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::showEvent(static_cast<QShowEvent*>(event));
}

char QCommandLinkButton_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QCommandLinkButton_CloseDefault(void* ptr)
{
	return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::close();
}

void QCommandLinkButton_CloseEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QCommandLinkButton_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::closeEvent(static_cast<QCloseEvent*>(event));
}

void QCommandLinkButton_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QCommandLinkButton_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QCommandLinkButton_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QCommandLinkButton*>(ptr)->focusNextPrevChild(next != 0);
}

char QCommandLinkButton_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::focusNextPrevChild(next != 0);
}

char QCommandLinkButton_HasHeightForWidth(void* ptr)
{
	return static_cast<QCommandLinkButton*>(ptr)->hasHeightForWidth();
}

char QCommandLinkButton_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::hasHeightForWidth();
}

void QCommandLinkButton_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "hide");
}

void QCommandLinkButton_HideDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::hide();
}

void QCommandLinkButton_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QCommandLinkButton_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QCommandLinkButton_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QCommandLinkButton*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QCommandLinkButton_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QCommandLinkButton_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "lower");
}

void QCommandLinkButton_LowerDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::lower();
}

void QCommandLinkButton_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QCommandLinkButton_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QCommandLinkButton_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QCommandLinkButton*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QCommandLinkButton_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QCommandLinkButton_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "raise");
}

void QCommandLinkButton_RaiseDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::raise();
}

void QCommandLinkButton_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "repaint");
}

void QCommandLinkButton_RepaintDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::repaint();
}

void QCommandLinkButton_ResizeEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QCommandLinkButton_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QCommandLinkButton_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QCommandLinkButton_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setDisabled(disable != 0);
}

void QCommandLinkButton_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "setFocus");
}

void QCommandLinkButton_SetFocus2Default(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setFocus();
}

void QCommandLinkButton_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QCommandLinkButton_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setHidden(hidden != 0);
}

void QCommandLinkButton_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "show");
}

void QCommandLinkButton_ShowDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::show();
}

void QCommandLinkButton_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "showFullScreen");
}

void QCommandLinkButton_ShowFullScreenDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::showFullScreen();
}

void QCommandLinkButton_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "showMaximized");
}

void QCommandLinkButton_ShowMaximizedDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::showMaximized();
}

void QCommandLinkButton_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "showMinimized");
}

void QCommandLinkButton_ShowMinimizedDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::showMinimized();
}

void QCommandLinkButton_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "showNormal");
}

void QCommandLinkButton_ShowNormalDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::showNormal();
}

void QCommandLinkButton_TabletEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QCommandLinkButton_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QCommandLinkButton_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "update");
}

void QCommandLinkButton_UpdateDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::update();
}

void QCommandLinkButton_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "updateMicroFocus");
}

void QCommandLinkButton_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::updateMicroFocus();
}

void QCommandLinkButton_WheelEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QCommandLinkButton_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QCommandLinkButton_ChildEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QCommandLinkButton_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QCommandLinkButton*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QCommandLinkButton_CustomEvent(void* ptr, void* event)
{
	static_cast<QCommandLinkButton*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QCommandLinkButton_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "deleteLater");
}

void QCommandLinkButton_DeleteLaterDefault(void* ptr)
{
	static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::deleteLater();
}

void QCommandLinkButton_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QCommandLinkButton*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QCommandLinkButton_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QCommandLinkButton*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QCommandLinkButton_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QCommandLinkButton_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QCommandLinkButton*>(ptr)->metaObject());
}

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

class MyQCommonStyle: public QCommonStyle
{
public:
	MyQCommonStyle() : QCommonStyle() {};
	void drawComplexControl(QStyle::ComplexControl cc, const QStyleOptionComplex * opt, QPainter * p, const QWidget * widget) const { callbackQCommonStyle_DrawComplexControl(const_cast<MyQCommonStyle*>(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<MyQCommonStyle*>(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<MyQCommonStyle*>(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<MyQCommonStyle*>(this), iconMode, const_cast<QPixmap*>(&pixmap), const_cast<QStyleOption*>(opt))); };
	SubControl hitTestComplexControl(QStyle::ComplexControl cc, const QStyleOptionComplex * opt, const QPoint & pt, const QWidget * widget) const { return static_cast<QStyle::SubControl>(callbackQCommonStyle_HitTestComplexControl(const_cast<MyQCommonStyle*>(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<MyQCommonStyle*>(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<MyQCommonStyle*>(this), m, const_cast<QStyleOption*>(opt), const_cast<QWidget*>(widget)); };
	void polish(QApplication * app) { callbackQCommonStyle_Polish2(this, app); };
	void polish(QPalette & pal) { callbackQCommonStyle_Polish(this, new QPalette(pal)); };
	void polish(QWidget * widget) { callbackQCommonStyle_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<MyQCommonStyle*>(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<MyQCommonStyle*>(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<MyQCommonStyle*>(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<MyQCommonStyle*>(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<MyQCommonStyle*>(this), sr, const_cast<QStyleOption*>(opt), const_cast<QWidget*>(widget))); };
	void unpolish(QApplication * application) { callbackQCommonStyle_Unpolish2(this, application); };
	void unpolish(QWidget * widget) { callbackQCommonStyle_Unpolish(this, widget); };
	void drawItemPixmap(QPainter * painter, const QRect & rectangle, int alignment, const QPixmap & pixmap) const { callbackQCommonStyle_DrawItemPixmap(const_cast<MyQCommonStyle*>(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 { callbackQCommonStyle_DrawItemText(const_cast<MyQCommonStyle*>(this), painter, const_cast<QRect*>(&rectangle), alignment, const_cast<QPalette*>(&palette), enabled, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10), textRole); };
	QRect itemPixmapRect(const QRect & rectangle, int alignment, const QPixmap & pixmap) const { return *static_cast<QRect*>(callbackQCommonStyle_ItemPixmapRect(const_cast<MyQCommonStyle*>(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 { return *static_cast<QRect*>(callbackQCommonStyle_ItemTextRect(const_cast<MyQCommonStyle*>(this), const_cast<QFontMetrics*>(&metrics), const_cast<QRect*>(&rectangle), alignment, enabled, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10))); };
	QIcon standardIcon(QStyle::StandardPixmap standardIcon, const QStyleOption * option, const QWidget * widget) const { return *static_cast<QIcon*>(callbackQCommonStyle_StandardIcon(const_cast<MyQCommonStyle*>(this), standardIcon, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
	QPalette standardPalette() const { return *static_cast<QPalette*>(callbackQCommonStyle_StandardPalette(const_cast<MyQCommonStyle*>(this))); };
	void timerEvent(QTimerEvent * event) { callbackQCommonStyle_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQCommonStyle_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQCommonStyle_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQCommonStyle_CustomEvent(this, event); };
	void deleteLater() { callbackQCommonStyle_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQCommonStyle_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQCommonStyle_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQCommonStyle_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCommonStyle_MetaObject(const_cast<MyQCommonStyle*>(this))); };
};

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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	return static_cast<QCommonStyle*>(ptr)->QCommonStyle::pixelMetric(static_cast<QStyle::PixelMetric>(m), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget));
}

void QCommonStyle_Polish2(void* ptr, void* app)
{
	static_cast<QCommonStyle*>(ptr)->polish(static_cast<QApplication*>(app));
}

void QCommonStyle_Polish2Default(void* ptr, void* app)
{
	static_cast<QCommonStyle*>(ptr)->QCommonStyle::polish(static_cast<QApplication*>(app));
}

void QCommonStyle_Polish(void* ptr, void* pal)
{
	static_cast<QCommonStyle*>(ptr)->polish(*static_cast<QPalette*>(pal));
}

void QCommonStyle_PolishDefault(void* ptr, void* pal)
{
	static_cast<QCommonStyle*>(ptr)->QCommonStyle::polish(*static_cast<QPalette*>(pal));
}

void QCommonStyle_Polish3(void* ptr, void* widget)
{
	static_cast<QCommonStyle*>(ptr)->polish(static_cast<QWidget*>(widget));
}

void QCommonStyle_Polish3Default(void* ptr, void* widget)
{
	static_cast<QCommonStyle*>(ptr)->QCommonStyle::polish(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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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_Unpolish2(void* ptr, void* application)
{
	static_cast<QCommonStyle*>(ptr)->unpolish(static_cast<QApplication*>(application));
}

void QCommonStyle_Unpolish2Default(void* ptr, void* application)
{
	static_cast<QCommonStyle*>(ptr)->QCommonStyle::unpolish(static_cast<QApplication*>(application));
}

void QCommonStyle_Unpolish(void* ptr, void* widget)
{
	static_cast<QCommonStyle*>(ptr)->unpolish(static_cast<QWidget*>(widget));
}

void QCommonStyle_UnpolishDefault(void* ptr, void* widget)
{
	static_cast<QCommonStyle*>(ptr)->QCommonStyle::unpolish(static_cast<QWidget*>(widget));
}

void QCommonStyle_DestroyQCommonStyle(void* ptr)
{
	static_cast<QCommonStyle*>(ptr)->~QCommonStyle();
}

void QCommonStyle_DrawItemPixmap(void* ptr, void* painter, void* rectangle, int alignment, void* pixmap)
{
	static_cast<QCommonStyle*>(ptr)->drawItemPixmap(static_cast<QPainter*>(painter), *static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap));
}

void QCommonStyle_DrawItemPixmapDefault(void* ptr, void* painter, void* rectangle, int alignment, void* pixmap)
{
	static_cast<QCommonStyle*>(ptr)->QCommonStyle::drawItemPixmap(static_cast<QPainter*>(painter), *static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap));
}

void QCommonStyle_DrawItemText(void* ptr, void* painter, void* rectangle, int alignment, void* palette, char enabled, char* text, long long textRole)
{
	static_cast<QCommonStyle*>(ptr)->drawItemText(static_cast<QPainter*>(painter), *static_cast<QRect*>(rectangle), alignment, *static_cast<QPalette*>(palette), enabled != 0, QString(text), static_cast<QPalette::ColorRole>(textRole));
}

void QCommonStyle_DrawItemTextDefault(void* ptr, void* painter, void* rectangle, int alignment, void* palette, char enabled, char* text, long long textRole)
{
	static_cast<QCommonStyle*>(ptr)->QCommonStyle::drawItemText(static_cast<QPainter*>(painter), *static_cast<QRect*>(rectangle), alignment, *static_cast<QPalette*>(palette), enabled != 0, QString(text), static_cast<QPalette::ColorRole>(textRole));
}

void* QCommonStyle_ItemPixmapRect(void* ptr, void* rectangle, int alignment, void* pixmap)
{
	return ({ QRect tmpValue = static_cast<QCommonStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QCommonStyle_ItemPixmapRectDefault(void* ptr, void* rectangle, int alignment, void* pixmap)
{
	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()); });
}

void* QCommonStyle_ItemTextRect(void* ptr, void* metrics, void* rectangle, int alignment, char enabled, char* text)
{
	return ({ QRect tmpValue = static_cast<QCommonStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QCommonStyle_ItemTextRectDefault(void* ptr, void* metrics, void* rectangle, int alignment, char enabled, char* text)
{
	return ({ QRect tmpValue = static_cast<QCommonStyle*>(ptr)->QCommonStyle::itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

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)
{
	return new QIcon(static_cast<QCommonStyle*>(ptr)->QCommonStyle::standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget)));
}

void* QCommonStyle_StandardPalette(void* ptr)
{
	return new QPalette(static_cast<QCommonStyle*>(ptr)->standardPalette());
}

void* QCommonStyle_StandardPaletteDefault(void* ptr)
{
	return new QPalette(static_cast<QCommonStyle*>(ptr)->QCommonStyle::standardPalette());
}

void QCommonStyle_TimerEvent(void* ptr, void* event)
{
	static_cast<QCommonStyle*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QCommonStyle_ChildEvent(void* ptr, void* event)
{
	static_cast<QCommonStyle*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QCommonStyle_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QCommonStyle*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QCommonStyle_CustomEvent(void* ptr, void* event)
{
	static_cast<QCommonStyle*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QCommonStyle_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCommonStyle*>(ptr), "deleteLater");
}

void QCommonStyle_DeleteLaterDefault(void* ptr)
{
	static_cast<QCommonStyle*>(ptr)->QCommonStyle::deleteLater();
}

void QCommonStyle_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QCommonStyle*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QCommonStyle_Event(void* ptr, void* e)
{
	return static_cast<QCommonStyle*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QCommonStyle_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QCommonStyle*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QCommonStyle_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QCommonStyle*>(ptr)->QCommonStyle::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QCommonStyle_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QCommonStyle*>(ptr)->metaObject());
}

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

class MyQCompleter: public QCompleter
{
public:
	MyQCompleter(QAbstractItemModel *model, QObject *parent) : QCompleter(model, parent) {};
	MyQCompleter(QObject *parent) : QCompleter(parent) {};
	MyQCompleter(const QStringList &list, QObject *parent) : QCompleter(list, parent) {};
	void setCompletionPrefix(const QString & prefix) { callbackQCompleter_SetCompletionPrefix(this, const_cast<char*>(prefix.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setWrapAround(bool wrap) { callbackQCompleter_SetWrapAround(this, wrap); };
	void Signal_Activated2(const QModelIndex & index) { callbackQCompleter_Activated2(this, const_cast<QModelIndex*>(&index)); };
	void Signal_Activated(const QString & text) { callbackQCompleter_Activated(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void complete(const QRect & rect) { callbackQCompleter_Complete(this, const_cast<QRect*>(&rect)); };
	void Signal_Highlighted2(const QModelIndex & index) { callbackQCompleter_Highlighted2(this, const_cast<QModelIndex*>(&index)); };
	void Signal_Highlighted(const QString & text) { callbackQCompleter_Highlighted(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	QString pathFromIndex(const QModelIndex & index) const { return QString(callbackQCompleter_PathFromIndex(const_cast<MyQCompleter*>(this), const_cast<QModelIndex*>(&index))); };
	QStringList splitPath(const QString & path) const { return QString(callbackQCompleter_SplitPath(const_cast<MyQCompleter*>(this), const_cast<char*>(path.toUtf8().prepend("WHITESPACE").constData()+10))).split("|", QString::SkipEmptyParts); };
	void timerEvent(QTimerEvent * event) { callbackQCompleter_TimerEvent(this, event); };
	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 disconnectNotify(const QMetaMethod & sign) { callbackQCompleter_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCompleter_MetaObject(const_cast<MyQCompleter*>(this))); };
};

long long QCompleter_CaseSensitivity(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->caseSensitivity();
}

int QCompleter_CompletionColumn(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->completionColumn();
}

long long QCompleter_CompletionMode(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->completionMode();
}

char* QCompleter_CompletionPrefix(void* ptr)
{
	return const_cast<char*>(static_cast<QCompleter*>(ptr)->completionPrefix().toUtf8().prepend("WHITESPACE").constData()+10);
}

int QCompleter_CompletionRole(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->completionRole();
}

long long QCompleter_FilterMode(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->filterMode();
}

int QCompleter_MaxVisibleItems(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->maxVisibleItems();
}

long long QCompleter_ModelSorting(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->modelSorting();
}

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, char* prefix)
{
	QMetaObject::invokeMethod(static_cast<QCompleter*>(ptr), "setCompletionPrefix", Q_ARG(QString, QString(prefix)));
}

void QCompleter_SetCompletionRole(void* ptr, int role)
{
	static_cast<QCompleter*>(ptr)->setCompletionRole(role);
}

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_SetModelSorting(void* ptr, long long sorting)
{
	static_cast<QCompleter*>(ptr)->setModelSorting(static_cast<QCompleter::ModelSorting>(sorting));
}

void QCompleter_SetWrapAround(void* ptr, char wrap)
{
	QMetaObject::invokeMethod(static_cast<QCompleter*>(ptr), "setWrapAround", Q_ARG(bool, wrap != 0));
}

char QCompleter_WrapAround(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->wrapAround();
}

void* QCompleter_NewQCompleter2(void* model, void* parent)
{
	return new MyQCompleter(static_cast<QAbstractItemModel*>(model), static_cast<QObject*>(parent));
}

void* QCompleter_NewQCompleter(void* parent)
{
	return new MyQCompleter(static_cast<QObject*>(parent));
}

void* QCompleter_NewQCompleter3(char* list, void* parent)
{
	return new MyQCompleter(QString(list).split("|", QString::SkipEmptyParts), static_cast<QObject*>(parent));
}

void QCompleter_ConnectActivated2(void* ptr)
{
	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));
}

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));
}

void QCompleter_ConnectActivated(void* ptr)
{
	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));
}

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, char* text)
{
	static_cast<QCompleter*>(ptr)->activated(QString(text));
}

void QCompleter_Complete(void* ptr, void* rect)
{
	QMetaObject::invokeMethod(static_cast<QCompleter*>(ptr), "complete", Q_ARG(QRect, *static_cast<QRect*>(rect)));
}

int QCompleter_CompletionCount(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->completionCount();
}

void* QCompleter_CompletionModel(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->completionModel();
}

char* QCompleter_CurrentCompletion(void* ptr)
{
	return const_cast<char*>(static_cast<QCompleter*>(ptr)->currentCompletion().toUtf8().prepend("WHITESPACE").constData()+10);
}

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_Event(void* ptr, void* ev)
{
	return static_cast<QCompleter*>(ptr)->event(static_cast<QEvent*>(ev));
}

char QCompleter_EventFilter(void* ptr, void* o, void* e)
{
	return static_cast<QCompleter*>(ptr)->eventFilter(static_cast<QObject*>(o), static_cast<QEvent*>(e));
}

void QCompleter_ConnectHighlighted2(void* ptr)
{
	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));
}

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));
}

void QCompleter_ConnectHighlighted(void* ptr)
{
	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));
}

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, char* text)
{
	static_cast<QCompleter*>(ptr)->highlighted(QString(text));
}

void* QCompleter_Model(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->model();
}

char* QCompleter_PathFromIndex(void* ptr, void* index)
{
	return const_cast<char*>(static_cast<QCompleter*>(ptr)->pathFromIndex(*static_cast<QModelIndex*>(index)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QCompleter_PathFromIndexDefault(void* ptr, void* index)
{
	return const_cast<char*>(static_cast<QCompleter*>(ptr)->QCompleter::pathFromIndex(*static_cast<QModelIndex*>(index)).toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QCompleter_Popup(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->popup();
}

char QCompleter_SetCurrentRow(void* ptr, int row)
{
	return static_cast<QCompleter*>(ptr)->setCurrentRow(row);
}

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

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));
}

char* QCompleter_SplitPath(void* ptr, char* path)
{
	return const_cast<char*>(static_cast<QCompleter*>(ptr)->splitPath(QString(path)).join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QCompleter_SplitPathDefault(void* ptr, char* path)
{
	return const_cast<char*>(static_cast<QCompleter*>(ptr)->QCompleter::splitPath(QString(path)).join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QCompleter_Widget(void* ptr)
{
	return static_cast<QCompleter*>(ptr)->widget();
}

void QCompleter_DestroyQCompleter(void* ptr)
{
	static_cast<QCompleter*>(ptr)->~QCompleter();
}

void QCompleter_TimerEvent(void* ptr, void* event)
{
	static_cast<QCompleter*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QCompleter_ChildEvent(void* ptr, void* event)
{
	static_cast<QCompleter*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QCompleter_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QCompleter*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QCompleter_CustomEvent(void* ptr, void* event)
{
	static_cast<QCompleter*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QCompleter_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QCompleter*>(ptr), "deleteLater");
}

void QCompleter_DeleteLaterDefault(void* ptr)
{
	static_cast<QCompleter*>(ptr)->QCompleter::deleteLater();
}

void QCompleter_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QCompleter*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void* QCompleter_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QCompleter*>(ptr)->metaObject());
}

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

class MyQDataWidgetMapper: public QDataWidgetMapper
{
public:
	MyQDataWidgetMapper(QObject *parent) : QDataWidgetMapper(parent) {};
	void setCurrentIndex(int index) { callbackQDataWidgetMapper_SetCurrentIndex(this, index); };
	void Signal_CurrentIndexChanged(int index) { callbackQDataWidgetMapper_CurrentIndexChanged(this, index); };
	void revert() { callbackQDataWidgetMapper_Revert(this); };
	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); };
	void timerEvent(QTimerEvent * event) { callbackQDataWidgetMapper_TimerEvent(this, event); };
	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 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<MyQDataWidgetMapper*>(this))); };
};

int QDataWidgetMapper_CurrentIndex(void* ptr)
{
	return static_cast<QDataWidgetMapper*>(ptr)->currentIndex();
}

long long QDataWidgetMapper_Orientation(void* ptr)
{
	return static_cast<QDataWidgetMapper*>(ptr)->orientation();
}

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_SetOrientation(void* ptr, long long aOrientation)
{
	static_cast<QDataWidgetMapper*>(ptr)->setOrientation(static_cast<Qt::Orientation>(aOrientation));
}

void QDataWidgetMapper_SetSubmitPolicy(void* ptr, long long policy)
{
	static_cast<QDataWidgetMapper*>(ptr)->setSubmitPolicy(static_cast<QDataWidgetMapper::SubmitPolicy>(policy));
}

long long QDataWidgetMapper_SubmitPolicy(void* ptr)
{
	return static_cast<QDataWidgetMapper*>(ptr)->submitPolicy();
}

void* QDataWidgetMapper_NewQDataWidgetMapper(void* parent)
{
	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, char* propertyName)
{
	static_cast<QDataWidgetMapper*>(ptr)->addMapping(static_cast<QWidget*>(widget), section, QByteArray::fromHex(QString(propertyName).toUtf8()));
}

void QDataWidgetMapper_ClearMapping(void* ptr)
{
	static_cast<QDataWidgetMapper*>(ptr)->clearMapping();
}

void QDataWidgetMapper_ConnectCurrentIndexChanged(void* ptr)
{
	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));
}

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();
}

char* QDataWidgetMapper_MappedPropertyName(void* ptr, void* widget)
{
	return const_cast<char*>(static_cast<QDataWidgetMapper*>(ptr)->mappedPropertyName(static_cast<QWidget*>(widget)).toHex().prepend("WHITESPACE").constData()+10);
}

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();
}

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_RootIndex(void* ptr)
{
	return new QModelIndex(static_cast<QDataWidgetMapper*>(ptr)->rootIndex());
}

void QDataWidgetMapper_SetCurrentModelIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "setCurrentModelIndex", Q_ARG(QModelIndex, *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_SetRootIndex(void* ptr, void* index)
{
	static_cast<QDataWidgetMapper*>(ptr)->setRootIndex(*static_cast<QModelIndex*>(index));
}

char QDataWidgetMapper_Submit(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "submit", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

void QDataWidgetMapper_ToFirst(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "toFirst");
}

void QDataWidgetMapper_ToLast(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "toLast");
}

void QDataWidgetMapper_ToNext(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "toNext");
}

void QDataWidgetMapper_ToPrevious(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "toPrevious");
}

void QDataWidgetMapper_DestroyQDataWidgetMapper(void* ptr)
{
	static_cast<QDataWidgetMapper*>(ptr)->~QDataWidgetMapper();
}

void QDataWidgetMapper_TimerEvent(void* ptr, void* event)
{
	static_cast<QDataWidgetMapper*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QDataWidgetMapper_ChildEvent(void* ptr, void* event)
{
	static_cast<QDataWidgetMapper*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QDataWidgetMapper_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QDataWidgetMapper*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QDataWidgetMapper_CustomEvent(void* ptr, void* event)
{
	static_cast<QDataWidgetMapper*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QDataWidgetMapper_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDataWidgetMapper*>(ptr), "deleteLater");
}

void QDataWidgetMapper_DeleteLaterDefault(void* ptr)
{
	static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::deleteLater();
}

void QDataWidgetMapper_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QDataWidgetMapper*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QDataWidgetMapper_Event(void* ptr, void* e)
{
	return static_cast<QDataWidgetMapper*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QDataWidgetMapper_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QDataWidgetMapper*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QDataWidgetMapper_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QDataWidgetMapper_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QDataWidgetMapper*>(ptr)->metaObject());
}

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

void* QDateEdit_NewQDateEdit(void* parent)
{
	return new QDateEdit(static_cast<QWidget*>(parent));
}

void* QDateEdit_NewQDateEdit2(void* date, void* parent)
{
	return new QDateEdit(*static_cast<QDate*>(date), static_cast<QWidget*>(parent));
}

void QDateEdit_DestroyQDateEdit(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->~QDateEdit();
}

void QDateEdit_SetDate(void* ptr, void* date)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setDate", Q_ARG(QDate, *static_cast<QDate*>(date)));
}

void QDateEdit_SetDateDefault(void* ptr, void* date)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::setDate(*static_cast<QDate*>(date));
}

void QDateEdit_SetDateTime(void* ptr, void* dateTime)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setDateTime", Q_ARG(QDateTime, *static_cast<QDateTime*>(dateTime)));
}

void QDateEdit_SetDateTimeDefault(void* ptr, void* dateTime)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::setDateTime(*static_cast<QDateTime*>(dateTime));
}

void QDateEdit_SetTime(void* ptr, void* time)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setTime", Q_ARG(QTime, *static_cast<QTime*>(time)));
}

void QDateEdit_SetTimeDefault(void* ptr, void* time)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::setTime(*static_cast<QTime*>(time));
}

void QDateEdit_Clear(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->clear();
}

void QDateEdit_ClearDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::clear();
}

void* QDateEdit_DateTimeFromText(void* ptr, char* text)
{
	return new QDateTime(static_cast<QDateEdit*>(ptr)->dateTimeFromText(QString(text)));
}

void* QDateEdit_DateTimeFromTextDefault(void* ptr, char* text)
{
	return new QDateTime(static_cast<QDateEdit*>(ptr)->QDateEdit::dateTimeFromText(QString(text)));
}

void QDateEdit_Fixup(void* ptr, char* input)
{
	static_cast<QDateEdit*>(ptr)->fixup(*(new QString(input)));
}

void QDateEdit_FixupDefault(void* ptr, char* input)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::fixup(*(new QString(input)));
}

void QDateEdit_FocusInEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDateEdit_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QDateEdit_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QDateEdit*>(ptr)->focusNextPrevChild(next != 0);
}

char QDateEdit_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QDateEdit*>(ptr)->QDateEdit::focusNextPrevChild(next != 0);
}

void QDateEdit_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QDateEdit_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QDateEdit_MousePressEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDateEdit_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDateEdit_PaintEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QDateEdit_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::paintEvent(static_cast<QPaintEvent*>(event));
}

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

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

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

void QDateEdit_StepByDefault(void* ptr, int steps)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::stepBy(steps);
}

long long QDateEdit_StepEnabled(void* ptr)
{
	return static_cast<QDateEdit*>(ptr)->stepEnabled();
}

long long QDateEdit_StepEnabledDefault(void* ptr)
{
	return static_cast<QDateEdit*>(ptr)->QDateEdit::stepEnabled();
}

char* QDateEdit_TextFromDateTime(void* ptr, void* dateTime)
{
	return const_cast<char*>(static_cast<QDateEdit*>(ptr)->textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QDateEdit_TextFromDateTimeDefault(void* ptr, void* dateTime)
{
	return const_cast<char*>(static_cast<QDateEdit*>(ptr)->QDateEdit::textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8().prepend("WHITESPACE").constData()+10);
}

long long QDateEdit_Validate(void* ptr, char* text, int pos)
{
	return static_cast<QDateEdit*>(ptr)->validate(*(new QString(text)), pos);
}

long long QDateEdit_ValidateDefault(void* ptr, char* text, int pos)
{
	return static_cast<QDateEdit*>(ptr)->QDateEdit::validate(*(new QString(text)), pos);
}

void QDateEdit_WheelEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDateEdit_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDateEdit_ChangeEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QDateEdit_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::changeEvent(static_cast<QEvent*>(event));
}

void QDateEdit_CloseEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QDateEdit_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::closeEvent(static_cast<QCloseEvent*>(event));
}

void QDateEdit_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QDateEdit_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QDateEdit_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDateEdit_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDateEdit_HideEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QDateEdit_HideEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::hideEvent(static_cast<QHideEvent*>(event));
}

void* QDateEdit_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QDateEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QDateEdit_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QDateEdit*>(ptr)->QDateEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QDateEdit_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QDateEdit_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void* QDateEdit_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDateEdit*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QDateEdit_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDateEdit*>(ptr)->QDateEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QDateEdit_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDateEdit_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDateEdit_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QDateEdit_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QDateEdit_ResizeEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QDateEdit_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::resizeEvent(static_cast<QResizeEvent*>(event));
}

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

void QDateEdit_SelectAllDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::selectAll();
}

void QDateEdit_ShowEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QDateEdit_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::showEvent(static_cast<QShowEvent*>(event));
}

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

void QDateEdit_StepDownDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::stepDown();
}

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

void QDateEdit_StepUpDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::stepUp();
}

void QDateEdit_ActionEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QDateEdit_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::actionEvent(static_cast<QActionEvent*>(event));
}

void QDateEdit_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDateEdit_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDateEdit_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDateEdit_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDateEdit_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDateEdit_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDateEdit_DropEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QDateEdit_DropEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::dropEvent(static_cast<QDropEvent*>(event));
}

void QDateEdit_EnterEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QDateEdit_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::enterEvent(static_cast<QEvent*>(event));
}

void QDateEdit_LeaveEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QDateEdit_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::leaveEvent(static_cast<QEvent*>(event));
}

void QDateEdit_MoveEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QDateEdit_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QDateEdit_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QDateEdit_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::setStyleSheet(QString(styleSheet));
}

void QDateEdit_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QDateEdit_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::setVisible(visible != 0);
}

void QDateEdit_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QDateEdit_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::setWindowModified(vbo != 0);
}

void QDateEdit_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QDateEdit_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::setWindowTitle(QString(vqs));
}

char QDateEdit_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QDateEdit_CloseDefault(void* ptr)
{
	return static_cast<QDateEdit*>(ptr)->QDateEdit::close();
}

char QDateEdit_HasHeightForWidth(void* ptr)
{
	return static_cast<QDateEdit*>(ptr)->hasHeightForWidth();
}

char QDateEdit_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QDateEdit*>(ptr)->QDateEdit::hasHeightForWidth();
}

int QDateEdit_HeightForWidth(void* ptr, int w)
{
	return static_cast<QDateEdit*>(ptr)->heightForWidth(w);
}

int QDateEdit_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QDateEdit*>(ptr)->QDateEdit::heightForWidth(w);
}

void QDateEdit_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "hide");
}

void QDateEdit_HideDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::hide();
}

void QDateEdit_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QDateEdit_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QDateEdit_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "lower");
}

void QDateEdit_LowerDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::lower();
}

void QDateEdit_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QDateEdit_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QDateEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDateEdit*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QDateEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDateEdit*>(ptr)->QDateEdit::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QDateEdit_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "raise");
}

void QDateEdit_RaiseDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::raise();
}

void QDateEdit_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "repaint");
}

void QDateEdit_RepaintDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::repaint();
}

void QDateEdit_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QDateEdit_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::setDisabled(disable != 0);
}

void QDateEdit_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setFocus");
}

void QDateEdit_SetFocus2Default(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::setFocus();
}

void QDateEdit_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QDateEdit_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::setHidden(hidden != 0);
}

void QDateEdit_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "show");
}

void QDateEdit_ShowDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::show();
}

void QDateEdit_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "showFullScreen");
}

void QDateEdit_ShowFullScreenDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::showFullScreen();
}

void QDateEdit_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "showMaximized");
}

void QDateEdit_ShowMaximizedDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::showMaximized();
}

void QDateEdit_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "showMinimized");
}

void QDateEdit_ShowMinimizedDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::showMinimized();
}

void QDateEdit_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "showNormal");
}

void QDateEdit_ShowNormalDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::showNormal();
}

void QDateEdit_TabletEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDateEdit_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDateEdit_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "update");
}

void QDateEdit_UpdateDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::update();
}

void QDateEdit_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "updateMicroFocus");
}

void QDateEdit_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::updateMicroFocus();
}

void QDateEdit_ChildEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QDateEdit_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QDateEdit*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QDateEdit_CustomEvent(void* ptr, void* event)
{
	static_cast<QDateEdit*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QDateEdit_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "deleteLater");
}

void QDateEdit_DeleteLaterDefault(void* ptr)
{
	static_cast<QDateEdit*>(ptr)->QDateEdit::deleteLater();
}

void QDateEdit_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QDateEdit*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QDateEdit_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QDateEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QDateEdit_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QDateEdit*>(ptr)->QDateEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QDateEdit_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QDateEdit*>(ptr)->metaObject());
}

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

class MyQDateTimeEdit: public QDateTimeEdit
{
public:
	MyQDateTimeEdit(const QDate &date, QWidget *parent) : QDateTimeEdit(date, parent) {};
	MyQDateTimeEdit(const QTime &time, QWidget *parent) : QDateTimeEdit(time, parent) {};
	MyQDateTimeEdit(QWidget *parent) : QDateTimeEdit(parent) {};
	MyQDateTimeEdit(const QDateTime &datetime, QWidget *parent) : QDateTimeEdit(datetime, parent) {};
	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 & time) { callbackQDateTimeEdit_SetTime(this, const_cast<QTime*>(&time)); };
	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 { return *static_cast<QDateTime*>(callbackQDateTimeEdit_DateTimeFromText(const_cast<MyQDateTimeEdit*>(this), const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10))); };
	void fixup(QString & input) const { callbackQDateTimeEdit_Fixup(const_cast<MyQDateTimeEdit*>(this), const_cast<char*>(input.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void focusInEvent(QFocusEvent * event) { callbackQDateTimeEdit_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQDateTimeEdit_FocusNextPrevChild(this, next) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQDateTimeEdit_KeyPressEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQDateTimeEdit_MousePressEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQDateTimeEdit_PaintEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQDateTimeEdit_SizeHint(const_cast<MyQDateTimeEdit*>(this))); };
	void stepBy(int steps) { callbackQDateTimeEdit_StepBy(this, steps); };
	StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQDateTimeEdit_StepEnabled(const_cast<MyQDateTimeEdit*>(this))); };
	QString textFromDateTime(const QDateTime & dateTime) const { return QString(callbackQDateTimeEdit_TextFromDateTime(const_cast<MyQDateTimeEdit*>(this), const_cast<QDateTime*>(&dateTime))); };
	void Signal_TimeChanged(const QTime & time) { callbackQDateTimeEdit_TimeChanged(this, const_cast<QTime*>(&time)); };
	QValidator::State validate(QString & text, int & pos) const { return static_cast<QValidator::State>(callbackQDateTimeEdit_Validate(const_cast<MyQDateTimeEdit*>(this), const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10), pos)); };
	void wheelEvent(QWheelEvent * event) { callbackQDateTimeEdit_WheelEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQDateTimeEdit_ChangeEvent(this, event); };
	void closeEvent(QCloseEvent * event) { callbackQDateTimeEdit_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQDateTimeEdit_ContextMenuEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQDateTimeEdit_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQDateTimeEdit_HideEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDateTimeEdit_InputMethodQuery(const_cast<MyQDateTimeEdit*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQDateTimeEdit_KeyReleaseEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDateTimeEdit_MinimumSizeHint(const_cast<MyQDateTimeEdit*>(this))); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQDateTimeEdit_MouseMoveEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQDateTimeEdit_MouseReleaseEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQDateTimeEdit_ResizeEvent(this, event); };
	void selectAll() { callbackQDateTimeEdit_SelectAll(this); };
	void showEvent(QShowEvent * event) { callbackQDateTimeEdit_ShowEvent(this, event); };
	void stepDown() { callbackQDateTimeEdit_StepDown(this); };
	void stepUp() { callbackQDateTimeEdit_StepUp(this); };
	void actionEvent(QActionEvent * event) { callbackQDateTimeEdit_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQDateTimeEdit_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDateTimeEdit_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQDateTimeEdit_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQDateTimeEdit_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQDateTimeEdit_EnterEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQDateTimeEdit_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQDateTimeEdit_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQDateTimeEdit_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQDateTimeEdit_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQDateTimeEdit_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQDateTimeEdit_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQDateTimeEdit_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQDateTimeEdit_Close(this) != 0; };
	bool hasHeightForWidth() const { return callbackQDateTimeEdit_HasHeightForWidth(const_cast<MyQDateTimeEdit*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQDateTimeEdit_HeightForWidth(const_cast<MyQDateTimeEdit*>(this), w); };
	void hide() { callbackQDateTimeEdit_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQDateTimeEdit_InputMethodEvent(this, event); };
	void lower() { callbackQDateTimeEdit_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDateTimeEdit_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDateTimeEdit_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQDateTimeEdit_Raise(this); };
	void repaint() { callbackQDateTimeEdit_Repaint(this); };
	void setDisabled(bool disable) { callbackQDateTimeEdit_SetDisabled(this, disable); };
	void setFocus() { callbackQDateTimeEdit_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQDateTimeEdit_SetHidden(this, hidden); };
	void show() { callbackQDateTimeEdit_Show(this); };
	void showFullScreen() { callbackQDateTimeEdit_ShowFullScreen(this); };
	void showMaximized() { callbackQDateTimeEdit_ShowMaximized(this); };
	void showMinimized() { callbackQDateTimeEdit_ShowMinimized(this); };
	void showNormal() { callbackQDateTimeEdit_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQDateTimeEdit_TabletEvent(this, event); };
	void update() { callbackQDateTimeEdit_Update(this); };
	void updateMicroFocus() { callbackQDateTimeEdit_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQDateTimeEdit_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQDateTimeEdit_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQDateTimeEdit_CustomEvent(this, event); };
	void deleteLater() { callbackQDateTimeEdit_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQDateTimeEdit_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQDateTimeEdit_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDateTimeEdit_MetaObject(const_cast<MyQDateTimeEdit*>(this))); };
};

void* QDateTimeEdit_NewQDateTimeEdit3(void* date, void* parent)
{
	return new MyQDateTimeEdit(*static_cast<QDate*>(date), static_cast<QWidget*>(parent));
}

void* QDateTimeEdit_NewQDateTimeEdit4(void* time, void* parent)
{
	return new MyQDateTimeEdit(*static_cast<QTime*>(time), static_cast<QWidget*>(parent));
}

char QDateTimeEdit_CalendarPopup(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->calendarPopup();
}

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_DateTime(void* ptr)
{
	return new QDateTime(static_cast<QDateTimeEdit*>(ptr)->dateTime());
}

char* QDateTimeEdit_DisplayFormat(void* ptr)
{
	return const_cast<char*>(static_cast<QDateTimeEdit*>(ptr)->displayFormat().toUtf8().prepend("WHITESPACE").constData()+10);
}

long long QDateTimeEdit_DisplayedSections(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->displayedSections();
}

void* QDateTimeEdit_MaximumDateTime(void* ptr)
{
	return new QDateTime(static_cast<QDateTimeEdit*>(ptr)->maximumDateTime());
}

void* QDateTimeEdit_MinimumDateTime(void* ptr)
{
	return new QDateTime(static_cast<QDateTimeEdit*>(ptr)->minimumDateTime());
}

int QDateTimeEdit_SectionCount(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->sectionCount();
}

char* QDateTimeEdit_SectionText(void* ptr, long long section)
{
	return const_cast<char*>(static_cast<QDateTimeEdit*>(ptr)->sectionText(static_cast<QDateTimeEdit::Section>(section)).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QDateTimeEdit_SetCalendarPopup(void* ptr, char enable)
{
	static_cast<QDateTimeEdit*>(ptr)->setCalendarPopup(enable != 0);
}

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(QDate, *static_cast<QDate*>(date)));
}

void QDateTimeEdit_SetDateTime(void* ptr, void* dateTime)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setDateTime", Q_ARG(QDateTime, *static_cast<QDateTime*>(dateTime)));
}

void QDateTimeEdit_SetDisplayFormat(void* ptr, char* format)
{
	static_cast<QDateTimeEdit*>(ptr)->setDisplayFormat(QString(format));
}

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_SetTime(void* ptr, void* time)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setTime", Q_ARG(QTime, *static_cast<QTime*>(time)));
}

void QDateTimeEdit_SetTimeSpec(void* ptr, long long spec)
{
	static_cast<QDateTimeEdit*>(ptr)->setTimeSpec(static_cast<Qt::TimeSpec>(spec));
}

long long QDateTimeEdit_TimeSpec(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->timeSpec();
}

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_CalendarWidget(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->calendarWidget();
}

void QDateTimeEdit_Clear(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->clear();
}

void QDateTimeEdit_ClearDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::clear();
}

void QDateTimeEdit_ConnectDateChanged(void* ptr)
{
	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));
}

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_ConnectDateTimeChanged(void* ptr)
{
	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));
}

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, char* text)
{
	return new QDateTime(static_cast<QDateTimeEdit*>(ptr)->dateTimeFromText(QString(text)));
}

void* QDateTimeEdit_DateTimeFromTextDefault(void* ptr, char* text)
{
	return new QDateTime(static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::dateTimeFromText(QString(text)));
}

char QDateTimeEdit_Event(void* ptr, void* event)
{
	return static_cast<QDateTimeEdit*>(ptr)->event(static_cast<QEvent*>(event));
}

void QDateTimeEdit_Fixup(void* ptr, char* input)
{
	static_cast<QDateTimeEdit*>(ptr)->fixup(*(new QString(input)));
}

void QDateTimeEdit_FixupDefault(void* ptr, char* input)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::fixup(*(new QString(input)));
}

void QDateTimeEdit_FocusInEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDateTimeEdit_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QDateTimeEdit_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QDateTimeEdit*>(ptr)->focusNextPrevChild(next != 0);
}

char QDateTimeEdit_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::focusNextPrevChild(next != 0);
}

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

void QDateTimeEdit_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QDateTimeEdit_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QDateTimeEdit_MousePressEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDateTimeEdit_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDateTimeEdit_PaintEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QDateTimeEdit_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::paintEvent(static_cast<QPaintEvent*>(event));
}

long long QDateTimeEdit_SectionAt(void* ptr, int index)
{
	return static_cast<QDateTimeEdit*>(ptr)->sectionAt(index);
}

void QDateTimeEdit_SetCalendarWidget(void* ptr, void* calendarWidget)
{
	static_cast<QDateTimeEdit*>(ptr)->setCalendarWidget(static_cast<QCalendarWidget*>(calendarWidget));
}

void QDateTimeEdit_SetDateRange(void* ptr, void* min, void* max)
{
	static_cast<QDateTimeEdit*>(ptr)->setDateRange(*static_cast<QDate*>(min), *static_cast<QDate*>(max));
}

void QDateTimeEdit_SetDateTimeRange(void* ptr, void* min, void* max)
{
	static_cast<QDateTimeEdit*>(ptr)->setDateTimeRange(*static_cast<QDateTime*>(min), *static_cast<QDateTime*>(max));
}

void QDateTimeEdit_SetSelectedSection(void* ptr, long long section)
{
	static_cast<QDateTimeEdit*>(ptr)->setSelectedSection(static_cast<QDateTimeEdit::Section>(section));
}

void QDateTimeEdit_SetTimeRange(void* ptr, void* min, void* max)
{
	static_cast<QDateTimeEdit*>(ptr)->setTimeRange(*static_cast<QTime*>(min), *static_cast<QTime*>(max));
}

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

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

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

void QDateTimeEdit_StepByDefault(void* ptr, int steps)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::stepBy(steps);
}

long long QDateTimeEdit_StepEnabled(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->stepEnabled();
}

long long QDateTimeEdit_StepEnabledDefault(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::stepEnabled();
}

char* QDateTimeEdit_TextFromDateTime(void* ptr, void* dateTime)
{
	return const_cast<char*>(static_cast<QDateTimeEdit*>(ptr)->textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QDateTimeEdit_TextFromDateTimeDefault(void* ptr, void* dateTime)
{
	return const_cast<char*>(static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QDateTimeEdit_ConnectTimeChanged(void* ptr)
{
	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));
}

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* time)
{
	static_cast<QDateTimeEdit*>(ptr)->timeChanged(*static_cast<QTime*>(time));
}

long long QDateTimeEdit_Validate(void* ptr, char* text, int pos)
{
	return static_cast<QDateTimeEdit*>(ptr)->validate(*(new QString(text)), pos);
}

long long QDateTimeEdit_ValidateDefault(void* ptr, char* text, int pos)
{
	return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::validate(*(new QString(text)), pos);
}

void QDateTimeEdit_WheelEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDateTimeEdit_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDateTimeEdit_DestroyQDateTimeEdit(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->~QDateTimeEdit();
}

void QDateTimeEdit_ChangeEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QDateTimeEdit_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::changeEvent(static_cast<QEvent*>(event));
}

void QDateTimeEdit_CloseEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QDateTimeEdit_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::closeEvent(static_cast<QCloseEvent*>(event));
}

void QDateTimeEdit_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QDateTimeEdit_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QDateTimeEdit_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDateTimeEdit_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDateTimeEdit_HideEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QDateTimeEdit_HideEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::hideEvent(static_cast<QHideEvent*>(event));
}

void* QDateTimeEdit_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QDateTimeEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QDateTimeEdit_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QDateTimeEdit_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QDateTimeEdit_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void* QDateTimeEdit_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDateTimeEdit*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QDateTimeEdit_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QDateTimeEdit_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDateTimeEdit_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDateTimeEdit_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QDateTimeEdit_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QDateTimeEdit_ResizeEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QDateTimeEdit_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::resizeEvent(static_cast<QResizeEvent*>(event));
}

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

void QDateTimeEdit_SelectAllDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::selectAll();
}

void QDateTimeEdit_ShowEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QDateTimeEdit_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::showEvent(static_cast<QShowEvent*>(event));
}

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

void QDateTimeEdit_StepDownDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::stepDown();
}

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

void QDateTimeEdit_StepUpDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::stepUp();
}

void QDateTimeEdit_ActionEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QDateTimeEdit_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::actionEvent(static_cast<QActionEvent*>(event));
}

void QDateTimeEdit_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDateTimeEdit_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDateTimeEdit_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDateTimeEdit_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDateTimeEdit_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDateTimeEdit_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDateTimeEdit_DropEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QDateTimeEdit_DropEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::dropEvent(static_cast<QDropEvent*>(event));
}

void QDateTimeEdit_EnterEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QDateTimeEdit_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::enterEvent(static_cast<QEvent*>(event));
}

void QDateTimeEdit_LeaveEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QDateTimeEdit_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::leaveEvent(static_cast<QEvent*>(event));
}

void QDateTimeEdit_MoveEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QDateTimeEdit_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QDateTimeEdit_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QDateTimeEdit_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setStyleSheet(QString(styleSheet));
}

void QDateTimeEdit_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QDateTimeEdit_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setVisible(visible != 0);
}

void QDateTimeEdit_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QDateTimeEdit_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setWindowModified(vbo != 0);
}

void QDateTimeEdit_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QDateTimeEdit_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setWindowTitle(QString(vqs));
}

char QDateTimeEdit_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QDateTimeEdit_CloseDefault(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::close();
}

char QDateTimeEdit_HasHeightForWidth(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->hasHeightForWidth();
}

char QDateTimeEdit_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::hasHeightForWidth();
}

int QDateTimeEdit_HeightForWidth(void* ptr, int w)
{
	return static_cast<QDateTimeEdit*>(ptr)->heightForWidth(w);
}

int QDateTimeEdit_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::heightForWidth(w);
}

void QDateTimeEdit_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "hide");
}

void QDateTimeEdit_HideDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::hide();
}

void QDateTimeEdit_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QDateTimeEdit_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QDateTimeEdit_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "lower");
}

void QDateTimeEdit_LowerDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::lower();
}

void QDateTimeEdit_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QDateTimeEdit_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QDateTimeEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDateTimeEdit*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QDateTimeEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QDateTimeEdit_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "raise");
}

void QDateTimeEdit_RaiseDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::raise();
}

void QDateTimeEdit_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "repaint");
}

void QDateTimeEdit_RepaintDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::repaint();
}

void QDateTimeEdit_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QDateTimeEdit_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setDisabled(disable != 0);
}

void QDateTimeEdit_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setFocus");
}

void QDateTimeEdit_SetFocus2Default(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setFocus();
}

void QDateTimeEdit_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QDateTimeEdit_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setHidden(hidden != 0);
}

void QDateTimeEdit_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "show");
}

void QDateTimeEdit_ShowDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::show();
}

void QDateTimeEdit_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "showFullScreen");
}

void QDateTimeEdit_ShowFullScreenDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::showFullScreen();
}

void QDateTimeEdit_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "showMaximized");
}

void QDateTimeEdit_ShowMaximizedDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::showMaximized();
}

void QDateTimeEdit_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "showMinimized");
}

void QDateTimeEdit_ShowMinimizedDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::showMinimized();
}

void QDateTimeEdit_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "showNormal");
}

void QDateTimeEdit_ShowNormalDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::showNormal();
}

void QDateTimeEdit_TabletEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDateTimeEdit_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDateTimeEdit_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "update");
}

void QDateTimeEdit_UpdateDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::update();
}

void QDateTimeEdit_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "updateMicroFocus");
}

void QDateTimeEdit_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::updateMicroFocus();
}

void QDateTimeEdit_ChildEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QDateTimeEdit_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QDateTimeEdit*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QDateTimeEdit_CustomEvent(void* ptr, void* event)
{
	static_cast<QDateTimeEdit*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QDateTimeEdit_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "deleteLater");
}

void QDateTimeEdit_DeleteLaterDefault(void* ptr)
{
	static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::deleteLater();
}

void QDateTimeEdit_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QDateTimeEdit*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QDateTimeEdit_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QDateTimeEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QDateTimeEdit_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QDateTimeEdit_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QDateTimeEdit*>(ptr)->metaObject());
}

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

class MyQDesktopWidget: public QDesktopWidget
{
public:
	void resizeEvent(QResizeEvent * event) { callbackQDesktopWidget_ResizeEvent(this, event); };
	void Signal_PrimaryScreenChanged() { callbackQDesktopWidget_PrimaryScreenChanged(this); };
	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); };
	void actionEvent(QActionEvent * event) { callbackQDesktopWidget_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQDesktopWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDesktopWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQDesktopWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQDesktopWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQDesktopWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQDesktopWidget_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQDesktopWidget_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQDesktopWidget_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQDesktopWidget_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDesktopWidget_MinimumSizeHint(const_cast<MyQDesktopWidget*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQDesktopWidget_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQDesktopWidget_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQDesktopWidget_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQDesktopWidget_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQDesktopWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQDesktopWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQDesktopWidget_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQDesktopWidget_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQDesktopWidget_SizeHint(const_cast<MyQDesktopWidget*>(this))); };
	void changeEvent(QEvent * event) { callbackQDesktopWidget_ChangeEvent(this, event); };
	bool close() { return callbackQDesktopWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQDesktopWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQDesktopWidget_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQDesktopWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQDesktopWidget_HasHeightForWidth(const_cast<MyQDesktopWidget*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQDesktopWidget_HeightForWidth(const_cast<MyQDesktopWidget*>(this), w); };
	void hide() { callbackQDesktopWidget_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQDesktopWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDesktopWidget_InputMethodQuery(const_cast<MyQDesktopWidget*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQDesktopWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQDesktopWidget_KeyReleaseEvent(this, event); };
	void lower() { callbackQDesktopWidget_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDesktopWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQDesktopWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQDesktopWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQDesktopWidget_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDesktopWidget_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQDesktopWidget_Raise(this); };
	void repaint() { callbackQDesktopWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQDesktopWidget_SetDisabled(this, disable); };
	void setFocus() { callbackQDesktopWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQDesktopWidget_SetHidden(this, hidden); };
	void show() { callbackQDesktopWidget_Show(this); };
	void showFullScreen() { callbackQDesktopWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQDesktopWidget_ShowMaximized(this); };
	void showMinimized() { callbackQDesktopWidget_ShowMinimized(this); };
	void showNormal() { callbackQDesktopWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQDesktopWidget_TabletEvent(this, event); };
	void update() { callbackQDesktopWidget_Update(this); };
	void updateMicroFocus() { callbackQDesktopWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQDesktopWidget_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQDesktopWidget_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQDesktopWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQDesktopWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQDesktopWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQDesktopWidget_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQDesktopWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQDesktopWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDesktopWidget_MetaObject(const_cast<MyQDesktopWidget*>(this))); };
};

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()); });
}

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()); });
}

char QDesktopWidget_IsVirtualDesktop(void* ptr)
{
	return static_cast<QDesktopWidget*>(ptr)->isVirtualDesktop();
}

int QDesktopWidget_PrimaryScreen(void* ptr)
{
	return static_cast<QDesktopWidget*>(ptr)->primaryScreen();
}

void QDesktopWidget_ResizeEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QDesktopWidget_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::resizeEvent(static_cast<QResizeEvent*>(event));
}

void* QDesktopWidget_Screen(void* ptr, int screen)
{
	return static_cast<QDesktopWidget*>(ptr)->screen(screen);
}

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()); });
}

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()); });
}

int QDesktopWidget_ScreenNumber2(void* ptr, void* point)
{
	return static_cast<QDesktopWidget*>(ptr)->screenNumber(*static_cast<QPoint*>(point));
}

int QDesktopWidget_ScreenNumber(void* ptr, void* widget)
{
	return static_cast<QDesktopWidget*>(ptr)->screenNumber(static_cast<QWidget*>(widget));
}

void* QDesktopWidget_AvailableGeometry3(void* ptr, void* p)
{
	return ({ QRect tmpValue = static_cast<QDesktopWidget*>(ptr)->availableGeometry(*static_cast<QPoint*>(p)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QDesktopWidget_ConnectPrimaryScreenChanged(void* ptr)
{
	QObject::connect(static_cast<QDesktopWidget*>(ptr), static_cast<void (QDesktopWidget::*)()>(&QDesktopWidget::primaryScreenChanged), static_cast<MyQDesktopWidget*>(ptr), static_cast<void (MyQDesktopWidget::*)()>(&MyQDesktopWidget::Signal_PrimaryScreenChanged));
}

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)
{
	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));
}

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);
}

int QDesktopWidget_ScreenCount(void* ptr)
{
	return static_cast<QDesktopWidget*>(ptr)->screenCount();
}

void QDesktopWidget_ConnectScreenCountChanged(void* ptr)
{
	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));
}

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_ScreenGeometry3(void* ptr, void* p)
{
	return ({ QRect tmpValue = static_cast<QDesktopWidget*>(ptr)->screenGeometry(*static_cast<QPoint*>(p)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QDesktopWidget_ConnectWorkAreaResized(void* ptr)
{
	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));
}

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_ActionEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QDesktopWidget_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::actionEvent(static_cast<QActionEvent*>(event));
}

void QDesktopWidget_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDesktopWidget_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDesktopWidget_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDesktopWidget_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDesktopWidget_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDesktopWidget_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDesktopWidget_DropEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QDesktopWidget_DropEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::dropEvent(static_cast<QDropEvent*>(event));
}

void QDesktopWidget_EnterEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QDesktopWidget_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::enterEvent(static_cast<QEvent*>(event));
}

void QDesktopWidget_FocusInEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDesktopWidget_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDesktopWidget_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDesktopWidget_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDesktopWidget_HideEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QDesktopWidget_HideEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::hideEvent(static_cast<QHideEvent*>(event));
}

void QDesktopWidget_LeaveEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QDesktopWidget_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::leaveEvent(static_cast<QEvent*>(event));
}

void* QDesktopWidget_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDesktopWidget*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QDesktopWidget_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QDesktopWidget_MoveEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QDesktopWidget_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::moveEvent(static_cast<QMoveEvent*>(event));
}

void QDesktopWidget_PaintEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QDesktopWidget_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::paintEvent(static_cast<QPaintEvent*>(event));
}

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

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

void QDesktopWidget_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QDesktopWidget_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setStyleSheet(QString(styleSheet));
}

void QDesktopWidget_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QDesktopWidget_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setVisible(visible != 0);
}

void QDesktopWidget_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QDesktopWidget_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setWindowModified(vbo != 0);
}

void QDesktopWidget_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QDesktopWidget_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setWindowTitle(QString(vqs));
}

void QDesktopWidget_ShowEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QDesktopWidget_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::showEvent(static_cast<QShowEvent*>(event));
}

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

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

void QDesktopWidget_ChangeEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QDesktopWidget_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::changeEvent(static_cast<QEvent*>(event));
}

char QDesktopWidget_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QDesktopWidget_CloseDefault(void* ptr)
{
	return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::close();
}

void QDesktopWidget_CloseEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QDesktopWidget_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::closeEvent(static_cast<QCloseEvent*>(event));
}

void QDesktopWidget_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QDesktopWidget_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QDesktopWidget_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QDesktopWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QDesktopWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::focusNextPrevChild(next != 0);
}

char QDesktopWidget_HasHeightForWidth(void* ptr)
{
	return static_cast<QDesktopWidget*>(ptr)->hasHeightForWidth();
}

char QDesktopWidget_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::hasHeightForWidth();
}

int QDesktopWidget_HeightForWidth(void* ptr, int w)
{
	return static_cast<QDesktopWidget*>(ptr)->heightForWidth(w);
}

int QDesktopWidget_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::heightForWidth(w);
}

void QDesktopWidget_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "hide");
}

void QDesktopWidget_HideDefault(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::hide();
}

void QDesktopWidget_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QDesktopWidget_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QDesktopWidget_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QDesktopWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QDesktopWidget_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QDesktopWidget_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QDesktopWidget_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QDesktopWidget_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QDesktopWidget_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QDesktopWidget_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "lower");
}

void QDesktopWidget_LowerDefault(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::lower();
}

void QDesktopWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QDesktopWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QDesktopWidget_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDesktopWidget_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDesktopWidget_MousePressEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDesktopWidget_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDesktopWidget_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QDesktopWidget_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QDesktopWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDesktopWidget*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QDesktopWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QDesktopWidget_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "raise");
}

void QDesktopWidget_RaiseDefault(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::raise();
}

void QDesktopWidget_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "repaint");
}

void QDesktopWidget_RepaintDefault(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::repaint();
}

void QDesktopWidget_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QDesktopWidget_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setDisabled(disable != 0);
}

void QDesktopWidget_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "setFocus");
}

void QDesktopWidget_SetFocus2Default(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setFocus();
}

void QDesktopWidget_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QDesktopWidget_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setHidden(hidden != 0);
}

void QDesktopWidget_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "show");
}

void QDesktopWidget_ShowDefault(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::show();
}

void QDesktopWidget_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "showFullScreen");
}

void QDesktopWidget_ShowFullScreenDefault(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::showFullScreen();
}

void QDesktopWidget_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "showMaximized");
}

void QDesktopWidget_ShowMaximizedDefault(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::showMaximized();
}

void QDesktopWidget_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "showMinimized");
}

void QDesktopWidget_ShowMinimizedDefault(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::showMinimized();
}

void QDesktopWidget_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "showNormal");
}

void QDesktopWidget_ShowNormalDefault(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::showNormal();
}

void QDesktopWidget_TabletEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDesktopWidget_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDesktopWidget_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "update");
}

void QDesktopWidget_UpdateDefault(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::update();
}

void QDesktopWidget_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "updateMicroFocus");
}

void QDesktopWidget_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::updateMicroFocus();
}

void QDesktopWidget_WheelEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDesktopWidget_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDesktopWidget_TimerEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QDesktopWidget_ChildEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QDesktopWidget_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QDesktopWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QDesktopWidget_CustomEvent(void* ptr, void* event)
{
	static_cast<QDesktopWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QDesktopWidget_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "deleteLater");
}

void QDesktopWidget_DeleteLaterDefault(void* ptr)
{
	static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::deleteLater();
}

void QDesktopWidget_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QDesktopWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QDesktopWidget_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QDesktopWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QDesktopWidget_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QDesktopWidget_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QDesktopWidget*>(ptr)->metaObject());
}

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

class MyQDial: public QDial
{
public:
	MyQDial(QWidget *parent) : QDial(parent) {};
	void setNotchesVisible(bool visible) { callbackQDial_SetNotchesVisible(this, visible); };
	void setWrapping(bool on) { callbackQDial_SetWrapping(this, on); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDial_MinimumSizeHint(const_cast<MyQDial*>(this))); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQDial_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQDial_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQDial_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * pe) { callbackQDial_PaintEvent(this, pe); };
	void resizeEvent(QResizeEvent * e) { callbackQDial_ResizeEvent(this, e); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQDial_SizeHint(const_cast<MyQDial*>(this))); };
	void sliderChange(QAbstractSlider::SliderChange change) { callbackQDial_SliderChange(this, change); };
	void setOrientation(Qt::Orientation vqt) { callbackQDial_SetOrientation(this, vqt); };
	void setValue(int vin) { callbackQDial_SetValue(this, vin); };
	void changeEvent(QEvent * ev) { callbackQDial_ChangeEvent(this, ev); };
	void keyPressEvent(QKeyEvent * ev) { callbackQDial_KeyPressEvent(this, ev); };
	void setRange(int min, int max) { callbackQDial_SetRange(this, min, max); };
	void wheelEvent(QWheelEvent * e) { callbackQDial_WheelEvent(this, e); };
	void actionEvent(QActionEvent * event) { callbackQDial_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQDial_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDial_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQDial_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQDial_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQDial_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQDial_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQDial_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQDial_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQDial_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQDial_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQDial_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQDial_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQDial_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQDial_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQDial_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQDial_ShowEvent(this, event); };
	bool close() { return callbackQDial_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQDial_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQDial_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQDial_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQDial_HasHeightForWidth(const_cast<MyQDial*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQDial_HeightForWidth(const_cast<MyQDial*>(this), w); };
	void hide() { callbackQDial_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQDial_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDial_InputMethodQuery(const_cast<MyQDial*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQDial_KeyReleaseEvent(this, event); };
	void lower() { callbackQDial_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDial_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDial_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQDial_Raise(this); };
	void repaint() { callbackQDial_Repaint(this); };
	void setDisabled(bool disable) { callbackQDial_SetDisabled(this, disable); };
	void setFocus() { callbackQDial_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQDial_SetHidden(this, hidden); };
	void show() { callbackQDial_Show(this); };
	void showFullScreen() { callbackQDial_ShowFullScreen(this); };
	void showMaximized() { callbackQDial_ShowMaximized(this); };
	void showMinimized() { callbackQDial_ShowMinimized(this); };
	void showNormal() { callbackQDial_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQDial_TabletEvent(this, event); };
	void update() { callbackQDial_Update(this); };
	void updateMicroFocus() { callbackQDial_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQDial_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQDial_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQDial_CustomEvent(this, event); };
	void deleteLater() { callbackQDial_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQDial_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQDial_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDial_MetaObject(const_cast<MyQDial*>(this))); };
};

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_SetWrapping(void* ptr, char on)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setWrapping", Q_ARG(bool, on != 0));
}

char QDial_Wrapping(void* ptr)
{
	return static_cast<QDial*>(ptr)->wrapping();
}

void* QDial_NewQDial(void* parent)
{
	return new MyQDial(static_cast<QWidget*>(parent));
}

char QDial_Event(void* ptr, void* e)
{
	return static_cast<QDial*>(ptr)->event(static_cast<QEvent*>(e));
}

void QDial_InitStyleOption(void* ptr, void* option)
{
	static_cast<QDial*>(ptr)->initStyleOption(static_cast<QStyleOptionSlider*>(option));
}

void* QDial_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDial*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QDial_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDial*>(ptr)->QDial::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QDial_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QDial*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QDial_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QDial*>(ptr)->QDial::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QDial_MousePressEvent(void* ptr, void* e)
{
	static_cast<QDial*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QDial_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QDial*>(ptr)->QDial::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QDial_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QDial*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QDial_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QDial*>(ptr)->QDial::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QDial_PaintEvent(void* ptr, void* pe)
{
	static_cast<QDial*>(ptr)->paintEvent(static_cast<QPaintEvent*>(pe));
}

void QDial_PaintEventDefault(void* ptr, void* pe)
{
	static_cast<QDial*>(ptr)->QDial::paintEvent(static_cast<QPaintEvent*>(pe));
}

void QDial_ResizeEvent(void* ptr, void* e)
{
	static_cast<QDial*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(e));
}

void QDial_ResizeEventDefault(void* ptr, void* e)
{
	static_cast<QDial*>(ptr)->QDial::resizeEvent(static_cast<QResizeEvent*>(e));
}

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

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

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

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

void QDial_DestroyQDial(void* ptr)
{
	static_cast<QDial*>(ptr)->~QDial();
}

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

void QDial_SetOrientationDefault(void* ptr, long long vqt)
{
	static_cast<QDial*>(ptr)->QDial::setOrientation(static_cast<Qt::Orientation>(vqt));
}

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

void QDial_SetValueDefault(void* ptr, int vin)
{
	static_cast<QDial*>(ptr)->QDial::setValue(vin);
}

void QDial_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QDial*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QDial_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QDial*>(ptr)->QDial::changeEvent(static_cast<QEvent*>(ev));
}

void QDial_KeyPressEvent(void* ptr, void* ev)
{
	static_cast<QDial*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(ev));
}

void QDial_KeyPressEventDefault(void* ptr, void* ev)
{
	static_cast<QDial*>(ptr)->QDial::keyPressEvent(static_cast<QKeyEvent*>(ev));
}

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

void QDial_SetRangeDefault(void* ptr, int min, int max)
{
	static_cast<QDial*>(ptr)->QDial::setRange(min, max);
}

void QDial_WheelEvent(void* ptr, void* e)
{
	static_cast<QDial*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QDial_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QDial*>(ptr)->QDial::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QDial_ActionEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QDial_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::actionEvent(static_cast<QActionEvent*>(event));
}

void QDial_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDial_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDial_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDial_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDial_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDial_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDial_DropEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QDial_DropEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::dropEvent(static_cast<QDropEvent*>(event));
}

void QDial_EnterEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QDial_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::enterEvent(static_cast<QEvent*>(event));
}

void QDial_FocusInEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDial_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDial_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDial_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDial_HideEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QDial_HideEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::hideEvent(static_cast<QHideEvent*>(event));
}

void QDial_LeaveEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QDial_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::leaveEvent(static_cast<QEvent*>(event));
}

void QDial_MoveEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QDial_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QDial_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QDial_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QDial*>(ptr)->QDial::setStyleSheet(QString(styleSheet));
}

void QDial_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QDial_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QDial*>(ptr)->QDial::setVisible(visible != 0);
}

void QDial_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QDial_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QDial*>(ptr)->QDial::setWindowModified(vbo != 0);
}

void QDial_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QDial_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QDial*>(ptr)->QDial::setWindowTitle(QString(vqs));
}

void QDial_ShowEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QDial_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::showEvent(static_cast<QShowEvent*>(event));
}

char QDial_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QDial_CloseDefault(void* ptr)
{
	return static_cast<QDial*>(ptr)->QDial::close();
}

void QDial_CloseEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QDial_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::closeEvent(static_cast<QCloseEvent*>(event));
}

void QDial_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QDial_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QDial_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QDial*>(ptr)->focusNextPrevChild(next != 0);
}

char QDial_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QDial*>(ptr)->QDial::focusNextPrevChild(next != 0);
}

char QDial_HasHeightForWidth(void* ptr)
{
	return static_cast<QDial*>(ptr)->hasHeightForWidth();
}

char QDial_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QDial*>(ptr)->QDial::hasHeightForWidth();
}

int QDial_HeightForWidth(void* ptr, int w)
{
	return static_cast<QDial*>(ptr)->heightForWidth(w);
}

int QDial_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QDial*>(ptr)->QDial::heightForWidth(w);
}

void QDial_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "hide");
}

void QDial_HideDefault(void* ptr)
{
	static_cast<QDial*>(ptr)->QDial::hide();
}

void QDial_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QDial_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QDial_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QDial*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QDial_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QDial*>(ptr)->QDial::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QDial_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QDial_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QDial_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "lower");
}

void QDial_LowerDefault(void* ptr)
{
	static_cast<QDial*>(ptr)->QDial::lower();
}

void QDial_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QDial_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QDial_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDial*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QDial_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDial*>(ptr)->QDial::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QDial_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "raise");
}

void QDial_RaiseDefault(void* ptr)
{
	static_cast<QDial*>(ptr)->QDial::raise();
}

void QDial_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "repaint");
}

void QDial_RepaintDefault(void* ptr)
{
	static_cast<QDial*>(ptr)->QDial::repaint();
}

void QDial_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QDial_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QDial*>(ptr)->QDial::setDisabled(disable != 0);
}

void QDial_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setFocus");
}

void QDial_SetFocus2Default(void* ptr)
{
	static_cast<QDial*>(ptr)->QDial::setFocus();
}

void QDial_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QDial_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QDial*>(ptr)->QDial::setHidden(hidden != 0);
}

void QDial_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "show");
}

void QDial_ShowDefault(void* ptr)
{
	static_cast<QDial*>(ptr)->QDial::show();
}

void QDial_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "showFullScreen");
}

void QDial_ShowFullScreenDefault(void* ptr)
{
	static_cast<QDial*>(ptr)->QDial::showFullScreen();
}

void QDial_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "showMaximized");
}

void QDial_ShowMaximizedDefault(void* ptr)
{
	static_cast<QDial*>(ptr)->QDial::showMaximized();
}

void QDial_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "showMinimized");
}

void QDial_ShowMinimizedDefault(void* ptr)
{
	static_cast<QDial*>(ptr)->QDial::showMinimized();
}

void QDial_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "showNormal");
}

void QDial_ShowNormalDefault(void* ptr)
{
	static_cast<QDial*>(ptr)->QDial::showNormal();
}

void QDial_TabletEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDial_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->QDial::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDial_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "update");
}

void QDial_UpdateDefault(void* ptr)
{
	static_cast<QDial*>(ptr)->QDial::update();
}

void QDial_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "updateMicroFocus");
}

void QDial_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QDial*>(ptr)->QDial::updateMicroFocus();
}

void QDial_ChildEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QDial_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QDial*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QDial_CustomEvent(void* ptr, void* event)
{
	static_cast<QDial*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QDial_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "deleteLater");
}

void QDial_DeleteLaterDefault(void* ptr)
{
	static_cast<QDial*>(ptr)->QDial::deleteLater();
}

void QDial_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QDial*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QDial_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QDial*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QDial_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QDial*>(ptr)->QDial::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QDial_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QDial*>(ptr)->metaObject());
}

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

class MyQDialog: public QDialog
{
public:
	MyQDialog(QWidget *parent, Qt::WindowFlags f) : QDialog(parent, f) {};
	void accept() { callbackQDialog_Accept(this); };
	void Signal_Accepted() { callbackQDialog_Accepted(this); };
	void closeEvent(QCloseEvent * e) { callbackQDialog_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQDialog_ContextMenuEvent(this, e); };
	void done(int r) { callbackQDialog_Done(this, r); };
	int exec() { return callbackQDialog_Exec(this); };
	void Signal_Finished(int result) { callbackQDialog_Finished(this, result); };
	void keyPressEvent(QKeyEvent * e) { callbackQDialog_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDialog_MinimumSizeHint(const_cast<MyQDialog*>(this))); };
	void open() { callbackQDialog_Open(this); };
	void reject() { callbackQDialog_Reject(this); };
	void Signal_Rejected() { callbackQDialog_Rejected(this); };
	void resizeEvent(QResizeEvent * vqr) { callbackQDialog_ResizeEvent(this, vqr); };
	void setVisible(bool visible) { callbackQDialog_SetVisible(this, visible); };
	void showEvent(QShowEvent * event) { callbackQDialog_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQDialog_SizeHint(const_cast<MyQDialog*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQDialog_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQDialog_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDialog_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQDialog_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQDialog_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQDialog_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQDialog_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQDialog_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQDialog_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQDialog_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQDialog_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQDialog_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQDialog_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQDialog_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setWindowModified(bool vbo) { callbackQDialog_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQDialog_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void changeEvent(QEvent * event) { callbackQDialog_ChangeEvent(this, event); };
	bool close() { return callbackQDialog_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQDialog_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQDialog_HasHeightForWidth(const_cast<MyQDialog*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQDialog_HeightForWidth(const_cast<MyQDialog*>(this), w); };
	void hide() { callbackQDialog_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQDialog_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDialog_InputMethodQuery(const_cast<MyQDialog*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQDialog_KeyReleaseEvent(this, event); };
	void lower() { callbackQDialog_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDialog_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQDialog_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQDialog_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQDialog_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDialog_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQDialog_Raise(this); };
	void repaint() { callbackQDialog_Repaint(this); };
	void setDisabled(bool disable) { callbackQDialog_SetDisabled(this, disable); };
	void setFocus() { callbackQDialog_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQDialog_SetHidden(this, hidden); };
	void show() { callbackQDialog_Show(this); };
	void showFullScreen() { callbackQDialog_ShowFullScreen(this); };
	void showMaximized() { callbackQDialog_ShowMaximized(this); };
	void showMinimized() { callbackQDialog_ShowMinimized(this); };
	void showNormal() { callbackQDialog_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQDialog_TabletEvent(this, event); };
	void update() { callbackQDialog_Update(this); };
	void updateMicroFocus() { callbackQDialog_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQDialog_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQDialog_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQDialog_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQDialog_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQDialog_CustomEvent(this, event); };
	void deleteLater() { callbackQDialog_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQDialog_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDialog_MetaObject(const_cast<MyQDialog*>(this))); };
};

char QDialog_IsSizeGripEnabled(void* ptr)
{
	return static_cast<QDialog*>(ptr)->isSizeGripEnabled();
}

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_NewQDialog(void* parent, long long f)
{
	return new MyQDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
}

void QDialog_Accept(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "accept");
}

void QDialog_AcceptDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::accept();
}

void QDialog_ConnectAccepted(void* ptr)
{
	QObject::connect(static_cast<QDialog*>(ptr), static_cast<void (QDialog::*)()>(&QDialog::accepted), static_cast<MyQDialog*>(ptr), static_cast<void (MyQDialog::*)()>(&MyQDialog::Signal_Accepted));
}

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_CloseEvent(void* ptr, void* e)
{
	static_cast<QDialog*>(ptr)->closeEvent(static_cast<QCloseEvent*>(e));
}

void QDialog_CloseEventDefault(void* ptr, void* e)
{
	static_cast<QDialog*>(ptr)->QDialog::closeEvent(static_cast<QCloseEvent*>(e));
}

void QDialog_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QDialog*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QDialog_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QDialog*>(ptr)->QDialog::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

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)
{
	static_cast<QDialog*>(ptr)->QDialog::done(r);
}

char QDialog_Event(void* ptr, void* e)
{
	return static_cast<QDialog*>(ptr)->event(static_cast<QEvent*>(e));
}

char QDialog_EventFilter(void* ptr, void* o, void* e)
{
	return static_cast<QDialog*>(ptr)->eventFilter(static_cast<QObject*>(o), static_cast<QEvent*>(e));
}

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)
{
	return static_cast<QDialog*>(ptr)->QDialog::exec();
}

void QDialog_ConnectFinished(void* ptr)
{
	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));
}

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);
}

void QDialog_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QDialog*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QDialog_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QDialog*>(ptr)->QDialog::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void* QDialog_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDialog*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QDialog_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDialog*>(ptr)->QDialog::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QDialog_Open(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "open");
}

void QDialog_OpenDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::open();
}

void QDialog_Reject(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "reject");
}

void QDialog_RejectDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::reject();
}

void QDialog_ConnectRejected(void* ptr)
{
	QObject::connect(static_cast<QDialog*>(ptr), static_cast<void (QDialog::*)()>(&QDialog::rejected), static_cast<MyQDialog*>(ptr), static_cast<void (MyQDialog::*)()>(&MyQDialog::Signal_Rejected));
}

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();
}

void QDialog_ResizeEvent(void* ptr, void* vqr)
{
	static_cast<QDialog*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QDialog_ResizeEventDefault(void* ptr, void* vqr)
{
	static_cast<QDialog*>(ptr)->QDialog::resizeEvent(static_cast<QResizeEvent*>(vqr));
}

int QDialog_Result(void* ptr)
{
	return static_cast<QDialog*>(ptr)->result();
}

void QDialog_SetVisible(void* ptr, char visible)
{
	static_cast<QDialog*>(ptr)->setVisible(visible != 0);
}

void QDialog_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QDialog*>(ptr)->QDialog::setVisible(visible != 0);
}

void QDialog_ShowEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QDialog_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::showEvent(static_cast<QShowEvent*>(event));
}

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

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

void QDialog_DestroyQDialog(void* ptr)
{
	static_cast<QDialog*>(ptr)->~QDialog();
}

void QDialog_ActionEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QDialog_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::actionEvent(static_cast<QActionEvent*>(event));
}

void QDialog_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDialog_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDialog_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDialog_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDialog_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDialog_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDialog_DropEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QDialog_DropEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::dropEvent(static_cast<QDropEvent*>(event));
}

void QDialog_EnterEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QDialog_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::enterEvent(static_cast<QEvent*>(event));
}

void QDialog_FocusInEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDialog_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDialog_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDialog_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDialog_HideEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QDialog_HideEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::hideEvent(static_cast<QHideEvent*>(event));
}

void QDialog_LeaveEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QDialog_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::leaveEvent(static_cast<QEvent*>(event));
}

void QDialog_MoveEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QDialog_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::moveEvent(static_cast<QMoveEvent*>(event));
}

void QDialog_PaintEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QDialog_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::paintEvent(static_cast<QPaintEvent*>(event));
}

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

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

void QDialog_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QDialog_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QDialog*>(ptr)->QDialog::setStyleSheet(QString(styleSheet));
}

void QDialog_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QDialog_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QDialog*>(ptr)->QDialog::setWindowModified(vbo != 0);
}

void QDialog_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QDialog_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QDialog*>(ptr)->QDialog::setWindowTitle(QString(vqs));
}

void QDialog_ChangeEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QDialog_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::changeEvent(static_cast<QEvent*>(event));
}

char QDialog_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QDialog_CloseDefault(void* ptr)
{
	return static_cast<QDialog*>(ptr)->QDialog::close();
}

char QDialog_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QDialog*>(ptr)->focusNextPrevChild(next != 0);
}

char QDialog_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QDialog*>(ptr)->QDialog::focusNextPrevChild(next != 0);
}

char QDialog_HasHeightForWidth(void* ptr)
{
	return static_cast<QDialog*>(ptr)->hasHeightForWidth();
}

char QDialog_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QDialog*>(ptr)->QDialog::hasHeightForWidth();
}

int QDialog_HeightForWidth(void* ptr, int w)
{
	return static_cast<QDialog*>(ptr)->heightForWidth(w);
}

int QDialog_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QDialog*>(ptr)->QDialog::heightForWidth(w);
}

void QDialog_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "hide");
}

void QDialog_HideDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::hide();
}

void QDialog_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QDialog_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QDialog_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QDialog*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QDialog_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QDialog*>(ptr)->QDialog::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QDialog_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QDialog_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QDialog_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "lower");
}

void QDialog_LowerDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::lower();
}

void QDialog_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QDialog_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QDialog_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDialog_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDialog_MousePressEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDialog_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDialog_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QDialog_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QDialog_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDialog*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QDialog_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDialog*>(ptr)->QDialog::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QDialog_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "raise");
}

void QDialog_RaiseDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::raise();
}

void QDialog_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "repaint");
}

void QDialog_RepaintDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::repaint();
}

void QDialog_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QDialog_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QDialog*>(ptr)->QDialog::setDisabled(disable != 0);
}

void QDialog_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "setFocus");
}

void QDialog_SetFocus2Default(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::setFocus();
}

void QDialog_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QDialog_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QDialog*>(ptr)->QDialog::setHidden(hidden != 0);
}

void QDialog_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "show");
}

void QDialog_ShowDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::show();
}

void QDialog_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "showFullScreen");
}

void QDialog_ShowFullScreenDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::showFullScreen();
}

void QDialog_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "showMaximized");
}

void QDialog_ShowMaximizedDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::showMaximized();
}

void QDialog_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "showMinimized");
}

void QDialog_ShowMinimizedDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::showMinimized();
}

void QDialog_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "showNormal");
}

void QDialog_ShowNormalDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::showNormal();
}

void QDialog_TabletEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDialog_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDialog_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "update");
}

void QDialog_UpdateDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::update();
}

void QDialog_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "updateMicroFocus");
}

void QDialog_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::updateMicroFocus();
}

void QDialog_WheelEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDialog_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->QDialog::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDialog_TimerEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QDialog_ChildEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QDialog_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QDialog*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QDialog_CustomEvent(void* ptr, void* event)
{
	static_cast<QDialog*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QDialog_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "deleteLater");
}

void QDialog_DeleteLaterDefault(void* ptr)
{
	static_cast<QDialog*>(ptr)->QDialog::deleteLater();
}

void QDialog_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QDialog*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void* QDialog_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QDialog*>(ptr)->metaObject());
}

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

class MyQDialogButtonBox: public QDialogButtonBox
{
public:
	MyQDialogButtonBox(QWidget *parent) : QDialogButtonBox(parent) {};
	MyQDialogButtonBox(Qt::Orientation orientation, QWidget *parent) : QDialogButtonBox(orientation, parent) {};
	MyQDialogButtonBox(StandardButtons buttons, QWidget *parent) : QDialogButtonBox(buttons, parent) {};
	MyQDialogButtonBox(StandardButtons buttons, Qt::Orientation orientation, QWidget *parent) : QDialogButtonBox(buttons, orientation, parent) {};
	void Signal_Accepted() { callbackQDialogButtonBox_Accepted(this); };
	void changeEvent(QEvent * event) { callbackQDialogButtonBox_ChangeEvent(this, event); };
	void Signal_Clicked(QAbstractButton * button) { callbackQDialogButtonBox_Clicked(this, button); };
	void Signal_HelpRequested() { callbackQDialogButtonBox_HelpRequested(this); };
	void Signal_Rejected() { callbackQDialogButtonBox_Rejected(this); };
	void actionEvent(QActionEvent * event) { callbackQDialogButtonBox_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQDialogButtonBox_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDialogButtonBox_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQDialogButtonBox_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQDialogButtonBox_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQDialogButtonBox_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQDialogButtonBox_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQDialogButtonBox_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQDialogButtonBox_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQDialogButtonBox_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDialogButtonBox_MinimumSizeHint(const_cast<MyQDialogButtonBox*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQDialogButtonBox_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQDialogButtonBox_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQDialogButtonBox_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQDialogButtonBox_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQDialogButtonBox_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQDialogButtonBox_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQDialogButtonBox_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQDialogButtonBox_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQDialogButtonBox_SizeHint(const_cast<MyQDialogButtonBox*>(this))); };
	bool close() { return callbackQDialogButtonBox_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQDialogButtonBox_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQDialogButtonBox_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQDialogButtonBox_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQDialogButtonBox_HasHeightForWidth(const_cast<MyQDialogButtonBox*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQDialogButtonBox_HeightForWidth(const_cast<MyQDialogButtonBox*>(this), w); };
	void hide() { callbackQDialogButtonBox_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQDialogButtonBox_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDialogButtonBox_InputMethodQuery(const_cast<MyQDialogButtonBox*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQDialogButtonBox_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQDialogButtonBox_KeyReleaseEvent(this, event); };
	void lower() { callbackQDialogButtonBox_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDialogButtonBox_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQDialogButtonBox_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQDialogButtonBox_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQDialogButtonBox_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDialogButtonBox_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQDialogButtonBox_Raise(this); };
	void repaint() { callbackQDialogButtonBox_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQDialogButtonBox_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQDialogButtonBox_SetDisabled(this, disable); };
	void setFocus() { callbackQDialogButtonBox_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQDialogButtonBox_SetHidden(this, hidden); };
	void show() { callbackQDialogButtonBox_Show(this); };
	void showFullScreen() { callbackQDialogButtonBox_ShowFullScreen(this); };
	void showMaximized() { callbackQDialogButtonBox_ShowMaximized(this); };
	void showMinimized() { callbackQDialogButtonBox_ShowMinimized(this); };
	void showNormal() { callbackQDialogButtonBox_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQDialogButtonBox_TabletEvent(this, event); };
	void update() { callbackQDialogButtonBox_Update(this); };
	void updateMicroFocus() { callbackQDialogButtonBox_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQDialogButtonBox_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQDialogButtonBox_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQDialogButtonBox_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQDialogButtonBox_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQDialogButtonBox_CustomEvent(this, event); };
	void deleteLater() { callbackQDialogButtonBox_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQDialogButtonBox_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQDialogButtonBox_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDialogButtonBox_MetaObject(const_cast<MyQDialogButtonBox*>(this))); };
};

char QDialogButtonBox_CenterButtons(void* ptr)
{
	return static_cast<QDialogButtonBox*>(ptr)->centerButtons();
}

long long QDialogButtonBox_Orientation(void* ptr)
{
	return static_cast<QDialogButtonBox*>(ptr)->orientation();
}

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_StandardButtons(void* ptr)
{
	return static_cast<QDialogButtonBox*>(ptr)->standardButtons();
}

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)
{
	QObject::connect(static_cast<QDialogButtonBox*>(ptr), static_cast<void (QDialogButtonBox::*)()>(&QDialogButtonBox::accepted), static_cast<MyQDialogButtonBox*>(ptr), static_cast<void (MyQDialogButtonBox::*)()>(&MyQDialogButtonBox::Signal_Accepted));
}

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_AddButton3(void* ptr, long long button)
{
	return static_cast<QDialogButtonBox*>(ptr)->addButton(static_cast<QDialogButtonBox::StandardButton>(button));
}

void* QDialogButtonBox_AddButton2(void* ptr, char* text, long long role)
{
	return static_cast<QDialogButtonBox*>(ptr)->addButton(QString(text), static_cast<QDialogButtonBox::ButtonRole>(role));
}

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_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));
}

void QDialogButtonBox_ChangeEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QDialogButtonBox_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::changeEvent(static_cast<QEvent*>(event));
}

void QDialogButtonBox_Clear(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->clear();
}

void QDialogButtonBox_ConnectClicked(void* ptr)
{
	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));
}

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));
}

char QDialogButtonBox_Event(void* ptr, void* event)
{
	return static_cast<QDialogButtonBox*>(ptr)->event(static_cast<QEvent*>(event));
}

void QDialogButtonBox_ConnectHelpRequested(void* ptr)
{
	QObject::connect(static_cast<QDialogButtonBox*>(ptr), static_cast<void (QDialogButtonBox::*)()>(&QDialogButtonBox::helpRequested), static_cast<MyQDialogButtonBox*>(ptr), static_cast<void (MyQDialogButtonBox::*)()>(&MyQDialogButtonBox::Signal_HelpRequested));
}

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();
}

void QDialogButtonBox_ConnectRejected(void* ptr)
{
	QObject::connect(static_cast<QDialogButtonBox*>(ptr), static_cast<void (QDialogButtonBox::*)()>(&QDialogButtonBox::rejected), static_cast<MyQDialogButtonBox*>(ptr), static_cast<void (MyQDialogButtonBox::*)()>(&MyQDialogButtonBox::Signal_Rejected));
}

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));
}

long long QDialogButtonBox_StandardButton(void* ptr, void* button)
{
	return static_cast<QDialogButtonBox*>(ptr)->standardButton(static_cast<QAbstractButton*>(button));
}

void QDialogButtonBox_DestroyQDialogButtonBox(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->~QDialogButtonBox();
}

void QDialogButtonBox_ActionEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QDialogButtonBox_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::actionEvent(static_cast<QActionEvent*>(event));
}

void QDialogButtonBox_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDialogButtonBox_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDialogButtonBox_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDialogButtonBox_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDialogButtonBox_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDialogButtonBox_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDialogButtonBox_DropEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QDialogButtonBox_DropEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::dropEvent(static_cast<QDropEvent*>(event));
}

void QDialogButtonBox_EnterEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QDialogButtonBox_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::enterEvent(static_cast<QEvent*>(event));
}

void QDialogButtonBox_FocusInEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDialogButtonBox_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDialogButtonBox_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDialogButtonBox_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDialogButtonBox_HideEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QDialogButtonBox_HideEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::hideEvent(static_cast<QHideEvent*>(event));
}

void QDialogButtonBox_LeaveEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QDialogButtonBox_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::leaveEvent(static_cast<QEvent*>(event));
}

void* QDialogButtonBox_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDialogButtonBox*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QDialogButtonBox_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QDialogButtonBox_MoveEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QDialogButtonBox_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::moveEvent(static_cast<QMoveEvent*>(event));
}

void QDialogButtonBox_PaintEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QDialogButtonBox_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::paintEvent(static_cast<QPaintEvent*>(event));
}

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

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

void QDialogButtonBox_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QDialogButtonBox_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setStyleSheet(QString(styleSheet));
}

void QDialogButtonBox_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QDialogButtonBox_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setVisible(visible != 0);
}

void QDialogButtonBox_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QDialogButtonBox_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setWindowModified(vbo != 0);
}

void QDialogButtonBox_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QDialogButtonBox_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setWindowTitle(QString(vqs));
}

void QDialogButtonBox_ShowEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QDialogButtonBox_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::showEvent(static_cast<QShowEvent*>(event));
}

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

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

char QDialogButtonBox_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QDialogButtonBox_CloseDefault(void* ptr)
{
	return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::close();
}

void QDialogButtonBox_CloseEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QDialogButtonBox_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::closeEvent(static_cast<QCloseEvent*>(event));
}

void QDialogButtonBox_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QDialogButtonBox_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QDialogButtonBox_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QDialogButtonBox*>(ptr)->focusNextPrevChild(next != 0);
}

char QDialogButtonBox_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::focusNextPrevChild(next != 0);
}

char QDialogButtonBox_HasHeightForWidth(void* ptr)
{
	return static_cast<QDialogButtonBox*>(ptr)->hasHeightForWidth();
}

char QDialogButtonBox_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::hasHeightForWidth();
}

int QDialogButtonBox_HeightForWidth(void* ptr, int w)
{
	return static_cast<QDialogButtonBox*>(ptr)->heightForWidth(w);
}

int QDialogButtonBox_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::heightForWidth(w);
}

void QDialogButtonBox_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "hide");
}

void QDialogButtonBox_HideDefault(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::hide();
}

void QDialogButtonBox_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QDialogButtonBox_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QDialogButtonBox_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QDialogButtonBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QDialogButtonBox_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QDialogButtonBox_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QDialogButtonBox_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QDialogButtonBox_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QDialogButtonBox_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QDialogButtonBox_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "lower");
}

void QDialogButtonBox_LowerDefault(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::lower();
}

void QDialogButtonBox_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QDialogButtonBox_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QDialogButtonBox_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDialogButtonBox_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDialogButtonBox_MousePressEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDialogButtonBox_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDialogButtonBox_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QDialogButtonBox_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QDialogButtonBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDialogButtonBox*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QDialogButtonBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QDialogButtonBox_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "raise");
}

void QDialogButtonBox_RaiseDefault(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::raise();
}

void QDialogButtonBox_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "repaint");
}

void QDialogButtonBox_RepaintDefault(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::repaint();
}

void QDialogButtonBox_ResizeEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QDialogButtonBox_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QDialogButtonBox_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QDialogButtonBox_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setDisabled(disable != 0);
}

void QDialogButtonBox_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "setFocus");
}

void QDialogButtonBox_SetFocus2Default(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setFocus();
}

void QDialogButtonBox_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QDialogButtonBox_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setHidden(hidden != 0);
}

void QDialogButtonBox_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "show");
}

void QDialogButtonBox_ShowDefault(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::show();
}

void QDialogButtonBox_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "showFullScreen");
}

void QDialogButtonBox_ShowFullScreenDefault(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::showFullScreen();
}

void QDialogButtonBox_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "showMaximized");
}

void QDialogButtonBox_ShowMaximizedDefault(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::showMaximized();
}

void QDialogButtonBox_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "showMinimized");
}

void QDialogButtonBox_ShowMinimizedDefault(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::showMinimized();
}

void QDialogButtonBox_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "showNormal");
}

void QDialogButtonBox_ShowNormalDefault(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::showNormal();
}

void QDialogButtonBox_TabletEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDialogButtonBox_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDialogButtonBox_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "update");
}

void QDialogButtonBox_UpdateDefault(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::update();
}

void QDialogButtonBox_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "updateMicroFocus");
}

void QDialogButtonBox_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::updateMicroFocus();
}

void QDialogButtonBox_WheelEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDialogButtonBox_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDialogButtonBox_TimerEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QDialogButtonBox_ChildEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QDialogButtonBox_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QDialogButtonBox*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QDialogButtonBox_CustomEvent(void* ptr, void* event)
{
	static_cast<QDialogButtonBox*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QDialogButtonBox_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "deleteLater");
}

void QDialogButtonBox_DeleteLaterDefault(void* ptr)
{
	static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::deleteLater();
}

void QDialogButtonBox_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QDialogButtonBox*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QDialogButtonBox_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QDialogButtonBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QDialogButtonBox_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QDialogButtonBox_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QDialogButtonBox*>(ptr)->metaObject());
}

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

class MyQDockWidget: public QDockWidget
{
public:
	MyQDockWidget(QWidget *parent, Qt::WindowFlags flags) : QDockWidget(parent, flags) {};
	MyQDockWidget(const QString &title, QWidget *parent, Qt::WindowFlags flags) : QDockWidget(title, parent, flags) {};
	void Signal_AllowedAreasChanged(Qt::DockWidgetAreas allowedAreas) { callbackQDockWidget_AllowedAreasChanged(this, allowedAreas); };
	void changeEvent(QEvent * event) { callbackQDockWidget_ChangeEvent(this, event); };
	void closeEvent(QCloseEvent * event) { callbackQDockWidget_CloseEvent(this, event); };
	void Signal_DockLocationChanged(Qt::DockWidgetArea area) { callbackQDockWidget_DockLocationChanged(this, area); };
	void Signal_FeaturesChanged(QDockWidget::DockWidgetFeatures features) { callbackQDockWidget_FeaturesChanged(this, features); };
	void paintEvent(QPaintEvent * event) { callbackQDockWidget_PaintEvent(this, event); };
	void Signal_TopLevelChanged(bool topLevel) { callbackQDockWidget_TopLevelChanged(this, topLevel); };
	void Signal_VisibilityChanged(bool visible) { callbackQDockWidget_VisibilityChanged(this, visible); };
	void actionEvent(QActionEvent * event) { callbackQDockWidget_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQDockWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDockWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQDockWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQDockWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQDockWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQDockWidget_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQDockWidget_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQDockWidget_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQDockWidget_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDockWidget_MinimumSizeHint(const_cast<MyQDockWidget*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQDockWidget_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQDockWidget_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQDockWidget_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQDockWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQDockWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQDockWidget_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQDockWidget_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQDockWidget_SizeHint(const_cast<MyQDockWidget*>(this))); };
	bool close() { return callbackQDockWidget_Close(this) != 0; };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQDockWidget_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQDockWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQDockWidget_HasHeightForWidth(const_cast<MyQDockWidget*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQDockWidget_HeightForWidth(const_cast<MyQDockWidget*>(this), w); };
	void hide() { callbackQDockWidget_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQDockWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDockWidget_InputMethodQuery(const_cast<MyQDockWidget*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQDockWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQDockWidget_KeyReleaseEvent(this, event); };
	void lower() { callbackQDockWidget_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDockWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQDockWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQDockWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQDockWidget_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDockWidget_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQDockWidget_Raise(this); };
	void repaint() { callbackQDockWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQDockWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQDockWidget_SetDisabled(this, disable); };
	void setFocus() { callbackQDockWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQDockWidget_SetHidden(this, hidden); };
	void show() { callbackQDockWidget_Show(this); };
	void showFullScreen() { callbackQDockWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQDockWidget_ShowMaximized(this); };
	void showMinimized() { callbackQDockWidget_ShowMinimized(this); };
	void showNormal() { callbackQDockWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQDockWidget_TabletEvent(this, event); };
	void update() { callbackQDockWidget_Update(this); };
	void updateMicroFocus() { callbackQDockWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQDockWidget_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQDockWidget_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQDockWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQDockWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQDockWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQDockWidget_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQDockWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQDockWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDockWidget_MetaObject(const_cast<MyQDockWidget*>(this))); };
};

long long QDockWidget_AllowedAreas(void* ptr)
{
	return static_cast<QDockWidget*>(ptr)->allowedAreas();
}

long long QDockWidget_Features(void* ptr)
{
	return static_cast<QDockWidget*>(ptr)->features();
}

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_NewQDockWidget2(void* parent, long long flags)
{
	return new MyQDockWidget(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}

void* QDockWidget_NewQDockWidget(char* title, void* parent, long long flags)
{
	return new MyQDockWidget(QString(title), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}

void QDockWidget_ConnectAllowedAreasChanged(void* ptr)
{
	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));
}

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_ChangeEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QDockWidget_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::changeEvent(static_cast<QEvent*>(event));
}

void QDockWidget_CloseEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QDockWidget_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::closeEvent(static_cast<QCloseEvent*>(event));
}

void QDockWidget_ConnectDockLocationChanged(void* ptr)
{
	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));
}

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));
}

char QDockWidget_Event(void* ptr, void* event)
{
	return static_cast<QDockWidget*>(ptr)->event(static_cast<QEvent*>(event));
}

void QDockWidget_ConnectFeaturesChanged(void* ptr)
{
	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));
}

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_PaintEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QDockWidget_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::paintEvent(static_cast<QPaintEvent*>(event));
}

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)
{
	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));
}

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)
{
	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));
}

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_ActionEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QDockWidget_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::actionEvent(static_cast<QActionEvent*>(event));
}

void QDockWidget_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDockWidget_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDockWidget_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDockWidget_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDockWidget_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDockWidget_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDockWidget_DropEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QDockWidget_DropEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::dropEvent(static_cast<QDropEvent*>(event));
}

void QDockWidget_EnterEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QDockWidget_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::enterEvent(static_cast<QEvent*>(event));
}

void QDockWidget_FocusInEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDockWidget_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDockWidget_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDockWidget_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDockWidget_HideEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QDockWidget_HideEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::hideEvent(static_cast<QHideEvent*>(event));
}

void QDockWidget_LeaveEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QDockWidget_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::leaveEvent(static_cast<QEvent*>(event));
}

void* QDockWidget_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDockWidget*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QDockWidget_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDockWidget*>(ptr)->QDockWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QDockWidget_MoveEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QDockWidget_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QDockWidget_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QDockWidget_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::setStyleSheet(QString(styleSheet));
}

void QDockWidget_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QDockWidget_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::setVisible(visible != 0);
}

void QDockWidget_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QDockWidget_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::setWindowModified(vbo != 0);
}

void QDockWidget_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QDockWidget_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::setWindowTitle(QString(vqs));
}

void QDockWidget_ShowEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QDockWidget_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::showEvent(static_cast<QShowEvent*>(event));
}

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

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

char QDockWidget_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QDockWidget_CloseDefault(void* ptr)
{
	return static_cast<QDockWidget*>(ptr)->QDockWidget::close();
}

void QDockWidget_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QDockWidget_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QDockWidget_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QDockWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QDockWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QDockWidget*>(ptr)->QDockWidget::focusNextPrevChild(next != 0);
}

char QDockWidget_HasHeightForWidth(void* ptr)
{
	return static_cast<QDockWidget*>(ptr)->hasHeightForWidth();
}

char QDockWidget_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QDockWidget*>(ptr)->QDockWidget::hasHeightForWidth();
}

int QDockWidget_HeightForWidth(void* ptr, int w)
{
	return static_cast<QDockWidget*>(ptr)->heightForWidth(w);
}

int QDockWidget_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QDockWidget*>(ptr)->QDockWidget::heightForWidth(w);
}

void QDockWidget_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "hide");
}

void QDockWidget_HideDefault(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::hide();
}

void QDockWidget_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QDockWidget_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QDockWidget_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QDockWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QDockWidget_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QDockWidget*>(ptr)->QDockWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QDockWidget_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QDockWidget_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QDockWidget_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QDockWidget_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QDockWidget_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "lower");
}

void QDockWidget_LowerDefault(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::lower();
}

void QDockWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QDockWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QDockWidget_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDockWidget_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDockWidget_MousePressEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDockWidget_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDockWidget_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QDockWidget_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QDockWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDockWidget*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QDockWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDockWidget*>(ptr)->QDockWidget::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QDockWidget_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "raise");
}

void QDockWidget_RaiseDefault(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::raise();
}

void QDockWidget_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "repaint");
}

void QDockWidget_RepaintDefault(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::repaint();
}

void QDockWidget_ResizeEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QDockWidget_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QDockWidget_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QDockWidget_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::setDisabled(disable != 0);
}

void QDockWidget_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "setFocus");
}

void QDockWidget_SetFocus2Default(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::setFocus();
}

void QDockWidget_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QDockWidget_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::setHidden(hidden != 0);
}

void QDockWidget_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "show");
}

void QDockWidget_ShowDefault(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::show();
}

void QDockWidget_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "showFullScreen");
}

void QDockWidget_ShowFullScreenDefault(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::showFullScreen();
}

void QDockWidget_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "showMaximized");
}

void QDockWidget_ShowMaximizedDefault(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::showMaximized();
}

void QDockWidget_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "showMinimized");
}

void QDockWidget_ShowMinimizedDefault(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::showMinimized();
}

void QDockWidget_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "showNormal");
}

void QDockWidget_ShowNormalDefault(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::showNormal();
}

void QDockWidget_TabletEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDockWidget_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDockWidget_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "update");
}

void QDockWidget_UpdateDefault(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::update();
}

void QDockWidget_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "updateMicroFocus");
}

void QDockWidget_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::updateMicroFocus();
}

void QDockWidget_WheelEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDockWidget_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDockWidget_TimerEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QDockWidget_ChildEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QDockWidget_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QDockWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QDockWidget_CustomEvent(void* ptr, void* event)
{
	static_cast<QDockWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QDockWidget_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "deleteLater");
}

void QDockWidget_DeleteLaterDefault(void* ptr)
{
	static_cast<QDockWidget*>(ptr)->QDockWidget::deleteLater();
}

void QDockWidget_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QDockWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QDockWidget_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QDockWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QDockWidget_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QDockWidget*>(ptr)->QDockWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QDockWidget_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QDockWidget*>(ptr)->metaObject());
}

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

class MyQDoubleSpinBox: public QDoubleSpinBox
{
public:
	MyQDoubleSpinBox(QWidget *parent) : QDoubleSpinBox(parent) {};
	void setValue(double val) { callbackQDoubleSpinBox_SetValue(this, val); };
	void fixup(QString & input) const { callbackQDoubleSpinBox_Fixup(const_cast<MyQDoubleSpinBox*>(this), const_cast<char*>(input.toUtf8().prepend("WHITESPACE").constData()+10)); };
	QString textFromValue(double value) const { return QString(callbackQDoubleSpinBox_TextFromValue(const_cast<MyQDoubleSpinBox*>(this), value)); };
	QValidator::State validate(QString & text, int & pos) const { return static_cast<QValidator::State>(callbackQDoubleSpinBox_Validate(const_cast<MyQDoubleSpinBox*>(this), const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10), pos)); };
	void Signal_ValueChanged2(const QString & text) { callbackQDoubleSpinBox_ValueChanged2(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_ValueChanged(double d) { callbackQDoubleSpinBox_ValueChanged(this, d); };
	double valueFromText(const QString & text) const { return callbackQDoubleSpinBox_ValueFromText(const_cast<MyQDoubleSpinBox*>(this), const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void changeEvent(QEvent * event) { callbackQDoubleSpinBox_ChangeEvent(this, event); };
	void clear() { callbackQDoubleSpinBox_Clear(this); };
	void closeEvent(QCloseEvent * event) { callbackQDoubleSpinBox_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQDoubleSpinBox_ContextMenuEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQDoubleSpinBox_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQDoubleSpinBox_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQDoubleSpinBox_HideEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDoubleSpinBox_InputMethodQuery(const_cast<MyQDoubleSpinBox*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQDoubleSpinBox_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQDoubleSpinBox_KeyReleaseEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDoubleSpinBox_MinimumSizeHint(const_cast<MyQDoubleSpinBox*>(this))); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQDoubleSpinBox_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQDoubleSpinBox_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQDoubleSpinBox_MouseReleaseEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQDoubleSpinBox_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQDoubleSpinBox_ResizeEvent(this, event); };
	void selectAll() { callbackQDoubleSpinBox_SelectAll(this); };
	void showEvent(QShowEvent * event) { callbackQDoubleSpinBox_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQDoubleSpinBox_SizeHint(const_cast<MyQDoubleSpinBox*>(this))); };
	void stepBy(int steps) { callbackQDoubleSpinBox_StepBy(this, steps); };
	void stepDown() { callbackQDoubleSpinBox_StepDown(this); };
	StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQDoubleSpinBox_StepEnabled(const_cast<MyQDoubleSpinBox*>(this))); };
	void stepUp() { callbackQDoubleSpinBox_StepUp(this); };
	void wheelEvent(QWheelEvent * event) { callbackQDoubleSpinBox_WheelEvent(this, event); };
	void actionEvent(QActionEvent * event) { callbackQDoubleSpinBox_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQDoubleSpinBox_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDoubleSpinBox_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQDoubleSpinBox_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQDoubleSpinBox_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQDoubleSpinBox_EnterEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQDoubleSpinBox_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQDoubleSpinBox_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQDoubleSpinBox_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQDoubleSpinBox_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQDoubleSpinBox_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQDoubleSpinBox_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQDoubleSpinBox_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQDoubleSpinBox_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQDoubleSpinBox_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQDoubleSpinBox_HasHeightForWidth(const_cast<MyQDoubleSpinBox*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQDoubleSpinBox_HeightForWidth(const_cast<MyQDoubleSpinBox*>(this), w); };
	void hide() { callbackQDoubleSpinBox_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQDoubleSpinBox_InputMethodEvent(this, event); };
	void lower() { callbackQDoubleSpinBox_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDoubleSpinBox_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDoubleSpinBox_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQDoubleSpinBox_Raise(this); };
	void repaint() { callbackQDoubleSpinBox_Repaint(this); };
	void setDisabled(bool disable) { callbackQDoubleSpinBox_SetDisabled(this, disable); };
	void setFocus() { callbackQDoubleSpinBox_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQDoubleSpinBox_SetHidden(this, hidden); };
	void show() { callbackQDoubleSpinBox_Show(this); };
	void showFullScreen() { callbackQDoubleSpinBox_ShowFullScreen(this); };
	void showMaximized() { callbackQDoubleSpinBox_ShowMaximized(this); };
	void showMinimized() { callbackQDoubleSpinBox_ShowMinimized(this); };
	void showNormal() { callbackQDoubleSpinBox_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQDoubleSpinBox_TabletEvent(this, event); };
	void update() { callbackQDoubleSpinBox_Update(this); };
	void updateMicroFocus() { callbackQDoubleSpinBox_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQDoubleSpinBox_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQDoubleSpinBox_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQDoubleSpinBox_CustomEvent(this, event); };
	void deleteLater() { callbackQDoubleSpinBox_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQDoubleSpinBox_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQDoubleSpinBox_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDoubleSpinBox_MetaObject(const_cast<MyQDoubleSpinBox*>(this))); };
};

char* QDoubleSpinBox_CleanText(void* ptr)
{
	return const_cast<char*>(static_cast<QDoubleSpinBox*>(ptr)->cleanText().toUtf8().prepend("WHITESPACE").constData()+10);
}

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();
}

char* QDoubleSpinBox_Prefix(void* ptr)
{
	return const_cast<char*>(static_cast<QDoubleSpinBox*>(ptr)->prefix().toUtf8().prepend("WHITESPACE").constData()+10);
}

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, char* prefix)
{
	static_cast<QDoubleSpinBox*>(ptr)->setPrefix(QString(prefix));
}

void QDoubleSpinBox_SetSingleStep(void* ptr, double val)
{
	static_cast<QDoubleSpinBox*>(ptr)->setSingleStep(val);
}

void QDoubleSpinBox_SetSuffix(void* ptr, char* suffix)
{
	static_cast<QDoubleSpinBox*>(ptr)->setSuffix(QString(suffix));
}

void QDoubleSpinBox_SetValue(void* ptr, double val)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setValue", Q_ARG(double, val));
}

double QDoubleSpinBox_SingleStep(void* ptr)
{
	return static_cast<QDoubleSpinBox*>(ptr)->singleStep();
}

char* QDoubleSpinBox_Suffix(void* ptr)
{
	return const_cast<char*>(static_cast<QDoubleSpinBox*>(ptr)->suffix().toUtf8().prepend("WHITESPACE").constData()+10);
}

double QDoubleSpinBox_Value(void* ptr)
{
	return static_cast<QDoubleSpinBox*>(ptr)->value();
}

void* QDoubleSpinBox_NewQDoubleSpinBox(void* parent)
{
	return new MyQDoubleSpinBox(static_cast<QWidget*>(parent));
}

void QDoubleSpinBox_Fixup(void* ptr, char* input)
{
	static_cast<QDoubleSpinBox*>(ptr)->fixup(*(new QString(input)));
}

void QDoubleSpinBox_FixupDefault(void* ptr, char* input)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::fixup(*(new QString(input)));
}

void QDoubleSpinBox_SetRange(void* ptr, double minimum, double maximum)
{
	static_cast<QDoubleSpinBox*>(ptr)->setRange(minimum, maximum);
}

char* QDoubleSpinBox_TextFromValue(void* ptr, double value)
{
	return const_cast<char*>(static_cast<QDoubleSpinBox*>(ptr)->textFromValue(value).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QDoubleSpinBox_TextFromValueDefault(void* ptr, double value)
{
	return const_cast<char*>(static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::textFromValue(value).toUtf8().prepend("WHITESPACE").constData()+10);
}

long long QDoubleSpinBox_Validate(void* ptr, char* text, int pos)
{
	return static_cast<QDoubleSpinBox*>(ptr)->validate(*(new QString(text)), pos);
}

long long QDoubleSpinBox_ValidateDefault(void* ptr, char* text, int pos)
{
	return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::validate(*(new QString(text)), pos);
}

void QDoubleSpinBox_ConnectValueChanged2(void* ptr)
{
	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));
}

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, char* text)
{
	static_cast<QDoubleSpinBox*>(ptr)->valueChanged(QString(text));
}

void QDoubleSpinBox_ConnectValueChanged(void* ptr)
{
	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));
}

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);
}

double QDoubleSpinBox_ValueFromText(void* ptr, char* text)
{
	return static_cast<QDoubleSpinBox*>(ptr)->valueFromText(QString(text));
}

double QDoubleSpinBox_ValueFromTextDefault(void* ptr, char* text)
{
	return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::valueFromText(QString(text));
}

void QDoubleSpinBox_DestroyQDoubleSpinBox(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->~QDoubleSpinBox();
}

void QDoubleSpinBox_ChangeEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QDoubleSpinBox_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::changeEvent(static_cast<QEvent*>(event));
}

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

void QDoubleSpinBox_ClearDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::clear();
}

void QDoubleSpinBox_CloseEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QDoubleSpinBox_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::closeEvent(static_cast<QCloseEvent*>(event));
}

void QDoubleSpinBox_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QDoubleSpinBox_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QDoubleSpinBox_FocusInEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDoubleSpinBox_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QDoubleSpinBox_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDoubleSpinBox_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QDoubleSpinBox_HideEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QDoubleSpinBox_HideEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::hideEvent(static_cast<QHideEvent*>(event));
}

void* QDoubleSpinBox_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QDoubleSpinBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QDoubleSpinBox_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QDoubleSpinBox_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QDoubleSpinBox_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QDoubleSpinBox_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QDoubleSpinBox_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void* QDoubleSpinBox_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDoubleSpinBox*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QDoubleSpinBox_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QDoubleSpinBox_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDoubleSpinBox_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QDoubleSpinBox_MousePressEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDoubleSpinBox_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QDoubleSpinBox_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QDoubleSpinBox_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QDoubleSpinBox_PaintEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QDoubleSpinBox_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::paintEvent(static_cast<QPaintEvent*>(event));
}

void QDoubleSpinBox_ResizeEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QDoubleSpinBox_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::resizeEvent(static_cast<QResizeEvent*>(event));
}

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

void QDoubleSpinBox_SelectAllDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::selectAll();
}

void QDoubleSpinBox_ShowEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QDoubleSpinBox_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::showEvent(static_cast<QShowEvent*>(event));
}

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

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

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

void QDoubleSpinBox_StepByDefault(void* ptr, int steps)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::stepBy(steps);
}

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

void QDoubleSpinBox_StepDownDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::stepDown();
}

long long QDoubleSpinBox_StepEnabled(void* ptr)
{
	return static_cast<QDoubleSpinBox*>(ptr)->stepEnabled();
}

long long QDoubleSpinBox_StepEnabledDefault(void* ptr)
{
	return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::stepEnabled();
}

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

void QDoubleSpinBox_StepUpDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::stepUp();
}

void QDoubleSpinBox_WheelEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDoubleSpinBox_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QDoubleSpinBox_ActionEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QDoubleSpinBox_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::actionEvent(static_cast<QActionEvent*>(event));
}

void QDoubleSpinBox_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDoubleSpinBox_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QDoubleSpinBox_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDoubleSpinBox_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QDoubleSpinBox_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDoubleSpinBox_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QDoubleSpinBox_DropEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QDoubleSpinBox_DropEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::dropEvent(static_cast<QDropEvent*>(event));
}

void QDoubleSpinBox_EnterEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QDoubleSpinBox_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::enterEvent(static_cast<QEvent*>(event));
}

void QDoubleSpinBox_LeaveEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QDoubleSpinBox_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::leaveEvent(static_cast<QEvent*>(event));
}

void QDoubleSpinBox_MoveEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QDoubleSpinBox_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QDoubleSpinBox_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QDoubleSpinBox_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setStyleSheet(QString(styleSheet));
}

void QDoubleSpinBox_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QDoubleSpinBox_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setVisible(visible != 0);
}

void QDoubleSpinBox_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QDoubleSpinBox_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setWindowModified(vbo != 0);
}

void QDoubleSpinBox_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QDoubleSpinBox_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setWindowTitle(QString(vqs));
}

char QDoubleSpinBox_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QDoubleSpinBox_CloseDefault(void* ptr)
{
	return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::close();
}

char QDoubleSpinBox_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QDoubleSpinBox*>(ptr)->focusNextPrevChild(next != 0);
}

char QDoubleSpinBox_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::focusNextPrevChild(next != 0);
}

char QDoubleSpinBox_HasHeightForWidth(void* ptr)
{
	return static_cast<QDoubleSpinBox*>(ptr)->hasHeightForWidth();
}

char QDoubleSpinBox_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::hasHeightForWidth();
}

int QDoubleSpinBox_HeightForWidth(void* ptr, int w)
{
	return static_cast<QDoubleSpinBox*>(ptr)->heightForWidth(w);
}

int QDoubleSpinBox_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::heightForWidth(w);
}

void QDoubleSpinBox_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "hide");
}

void QDoubleSpinBox_HideDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::hide();
}

void QDoubleSpinBox_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QDoubleSpinBox_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QDoubleSpinBox_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "lower");
}

void QDoubleSpinBox_LowerDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::lower();
}

void QDoubleSpinBox_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QDoubleSpinBox_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QDoubleSpinBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDoubleSpinBox*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QDoubleSpinBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QDoubleSpinBox_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "raise");
}

void QDoubleSpinBox_RaiseDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::raise();
}

void QDoubleSpinBox_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "repaint");
}

void QDoubleSpinBox_RepaintDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::repaint();
}

void QDoubleSpinBox_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QDoubleSpinBox_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setDisabled(disable != 0);
}

void QDoubleSpinBox_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setFocus");
}

void QDoubleSpinBox_SetFocus2Default(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setFocus();
}

void QDoubleSpinBox_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QDoubleSpinBox_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setHidden(hidden != 0);
}

void QDoubleSpinBox_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "show");
}

void QDoubleSpinBox_ShowDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::show();
}

void QDoubleSpinBox_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "showFullScreen");
}

void QDoubleSpinBox_ShowFullScreenDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::showFullScreen();
}

void QDoubleSpinBox_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "showMaximized");
}

void QDoubleSpinBox_ShowMaximizedDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::showMaximized();
}

void QDoubleSpinBox_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "showMinimized");
}

void QDoubleSpinBox_ShowMinimizedDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::showMinimized();
}

void QDoubleSpinBox_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "showNormal");
}

void QDoubleSpinBox_ShowNormalDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::showNormal();
}

void QDoubleSpinBox_TabletEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDoubleSpinBox_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QDoubleSpinBox_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "update");
}

void QDoubleSpinBox_UpdateDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::update();
}

void QDoubleSpinBox_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "updateMicroFocus");
}

void QDoubleSpinBox_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::updateMicroFocus();
}

void QDoubleSpinBox_ChildEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QDoubleSpinBox_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QDoubleSpinBox*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QDoubleSpinBox_CustomEvent(void* ptr, void* event)
{
	static_cast<QDoubleSpinBox*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QDoubleSpinBox_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "deleteLater");
}

void QDoubleSpinBox_DeleteLaterDefault(void* ptr)
{
	static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::deleteLater();
}

void QDoubleSpinBox_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QDoubleSpinBox*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QDoubleSpinBox_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QDoubleSpinBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QDoubleSpinBox_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QDoubleSpinBox_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QDoubleSpinBox*>(ptr)->metaObject());
}

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

class MyQErrorMessage: public QErrorMessage
{
public:
	MyQErrorMessage(QWidget *parent) : QErrorMessage(parent) {};
	void changeEvent(QEvent * e) { callbackQErrorMessage_ChangeEvent(this, e); };
	void done(int a) { callbackQErrorMessage_Done(this, a); };
	void showMessage(const QString & message) { callbackQErrorMessage_ShowMessage(this, const_cast<char*>(message.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showMessage(const QString & message, const QString & ty) { callbackQErrorMessage_ShowMessage2(this, const_cast<char*>(message.toUtf8().prepend("WHITESPACE").constData()+10), const_cast<char*>(ty.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void accept() { callbackQErrorMessage_Accept(this); };
	void closeEvent(QCloseEvent * e) { callbackQErrorMessage_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQErrorMessage_ContextMenuEvent(this, e); };
	int exec() { return callbackQErrorMessage_Exec(this); };
	void keyPressEvent(QKeyEvent * e) { callbackQErrorMessage_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQErrorMessage_MinimumSizeHint(const_cast<MyQErrorMessage*>(this))); };
	void open() { callbackQErrorMessage_Open(this); };
	void reject() { callbackQErrorMessage_Reject(this); };
	void resizeEvent(QResizeEvent * vqr) { callbackQErrorMessage_ResizeEvent(this, vqr); };
	void setVisible(bool visible) { callbackQErrorMessage_SetVisible(this, visible); };
	void showEvent(QShowEvent * event) { callbackQErrorMessage_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQErrorMessage_SizeHint(const_cast<MyQErrorMessage*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQErrorMessage_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQErrorMessage_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQErrorMessage_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQErrorMessage_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQErrorMessage_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQErrorMessage_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQErrorMessage_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQErrorMessage_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQErrorMessage_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQErrorMessage_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQErrorMessage_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQErrorMessage_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQErrorMessage_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQErrorMessage_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setWindowModified(bool vbo) { callbackQErrorMessage_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQErrorMessage_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQErrorMessage_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQErrorMessage_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQErrorMessage_HasHeightForWidth(const_cast<MyQErrorMessage*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQErrorMessage_HeightForWidth(const_cast<MyQErrorMessage*>(this), w); };
	void hide() { callbackQErrorMessage_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQErrorMessage_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQErrorMessage_InputMethodQuery(const_cast<MyQErrorMessage*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQErrorMessage_KeyReleaseEvent(this, event); };
	void lower() { callbackQErrorMessage_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQErrorMessage_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQErrorMessage_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQErrorMessage_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQErrorMessage_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQErrorMessage_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQErrorMessage_Raise(this); };
	void repaint() { callbackQErrorMessage_Repaint(this); };
	void setDisabled(bool disable) { callbackQErrorMessage_SetDisabled(this, disable); };
	void setFocus() { callbackQErrorMessage_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQErrorMessage_SetHidden(this, hidden); };
	void show() { callbackQErrorMessage_Show(this); };
	void showFullScreen() { callbackQErrorMessage_ShowFullScreen(this); };
	void showMaximized() { callbackQErrorMessage_ShowMaximized(this); };
	void showMinimized() { callbackQErrorMessage_ShowMinimized(this); };
	void showNormal() { callbackQErrorMessage_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQErrorMessage_TabletEvent(this, event); };
	void update() { callbackQErrorMessage_Update(this); };
	void updateMicroFocus() { callbackQErrorMessage_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQErrorMessage_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQErrorMessage_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQErrorMessage_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQErrorMessage_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQErrorMessage_CustomEvent(this, event); };
	void deleteLater() { callbackQErrorMessage_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQErrorMessage_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQErrorMessage_MetaObject(const_cast<MyQErrorMessage*>(this))); };
};

void* QErrorMessage_NewQErrorMessage(void* parent)
{
	return new MyQErrorMessage(static_cast<QWidget*>(parent));
}

void QErrorMessage_ChangeEvent(void* ptr, void* e)
{
	static_cast<QErrorMessage*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QErrorMessage_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::changeEvent(static_cast<QEvent*>(e));
}

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, char* message)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "showMessage", Q_ARG(QString, QString(message)));
}

void QErrorMessage_ShowMessage2(void* ptr, char* message, char* ty)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "showMessage", Q_ARG(QString, QString(message)), Q_ARG(QString, QString(ty)));
}

void QErrorMessage_DestroyQErrorMessage(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->~QErrorMessage();
}

void QErrorMessage_Accept(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "accept");
}

void QErrorMessage_AcceptDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::accept();
}

void QErrorMessage_CloseEvent(void* ptr, void* e)
{
	static_cast<QErrorMessage*>(ptr)->closeEvent(static_cast<QCloseEvent*>(e));
}

void QErrorMessage_CloseEventDefault(void* ptr, void* e)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::closeEvent(static_cast<QCloseEvent*>(e));
}

void QErrorMessage_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QErrorMessage*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QErrorMessage_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

int QErrorMessage_Exec(void* ptr)
{
	int returnArg;
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "exec", Q_RETURN_ARG(int, returnArg));
	return returnArg;
}

int QErrorMessage_ExecDefault(void* ptr)
{
	return static_cast<QErrorMessage*>(ptr)->QErrorMessage::exec();
}

void QErrorMessage_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QErrorMessage*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QErrorMessage_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void* QErrorMessage_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QErrorMessage*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QErrorMessage_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QErrorMessage*>(ptr)->QErrorMessage::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QErrorMessage_Open(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "open");
}

void QErrorMessage_OpenDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::open();
}

void QErrorMessage_Reject(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "reject");
}

void QErrorMessage_RejectDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::reject();
}

void QErrorMessage_ResizeEvent(void* ptr, void* vqr)
{
	static_cast<QErrorMessage*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QErrorMessage_ResizeEventDefault(void* ptr, void* vqr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QErrorMessage_SetVisible(void* ptr, char visible)
{
	static_cast<QErrorMessage*>(ptr)->setVisible(visible != 0);
}

void QErrorMessage_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::setVisible(visible != 0);
}

void QErrorMessage_ShowEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QErrorMessage_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::showEvent(static_cast<QShowEvent*>(event));
}

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

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

void QErrorMessage_ActionEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QErrorMessage_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::actionEvent(static_cast<QActionEvent*>(event));
}

void QErrorMessage_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QErrorMessage_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QErrorMessage_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QErrorMessage_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QErrorMessage_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QErrorMessage_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QErrorMessage_DropEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QErrorMessage_DropEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::dropEvent(static_cast<QDropEvent*>(event));
}

void QErrorMessage_EnterEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QErrorMessage_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::enterEvent(static_cast<QEvent*>(event));
}

void QErrorMessage_FocusInEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QErrorMessage_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QErrorMessage_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QErrorMessage_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QErrorMessage_HideEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QErrorMessage_HideEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::hideEvent(static_cast<QHideEvent*>(event));
}

void QErrorMessage_LeaveEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QErrorMessage_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::leaveEvent(static_cast<QEvent*>(event));
}

void QErrorMessage_MoveEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QErrorMessage_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::moveEvent(static_cast<QMoveEvent*>(event));
}

void QErrorMessage_PaintEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QErrorMessage_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::paintEvent(static_cast<QPaintEvent*>(event));
}

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

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

void QErrorMessage_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QErrorMessage_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::setStyleSheet(QString(styleSheet));
}

void QErrorMessage_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QErrorMessage_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::setWindowModified(vbo != 0);
}

void QErrorMessage_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QErrorMessage_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::setWindowTitle(QString(vqs));
}

char QErrorMessage_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QErrorMessage_CloseDefault(void* ptr)
{
	return static_cast<QErrorMessage*>(ptr)->QErrorMessage::close();
}

char QErrorMessage_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QErrorMessage*>(ptr)->focusNextPrevChild(next != 0);
}

char QErrorMessage_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QErrorMessage*>(ptr)->QErrorMessage::focusNextPrevChild(next != 0);
}

char QErrorMessage_HasHeightForWidth(void* ptr)
{
	return static_cast<QErrorMessage*>(ptr)->hasHeightForWidth();
}

char QErrorMessage_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QErrorMessage*>(ptr)->QErrorMessage::hasHeightForWidth();
}

int QErrorMessage_HeightForWidth(void* ptr, int w)
{
	return static_cast<QErrorMessage*>(ptr)->heightForWidth(w);
}

int QErrorMessage_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QErrorMessage*>(ptr)->QErrorMessage::heightForWidth(w);
}

void QErrorMessage_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "hide");
}

void QErrorMessage_HideDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::hide();
}

void QErrorMessage_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QErrorMessage_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QErrorMessage_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QErrorMessage*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QErrorMessage_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QErrorMessage*>(ptr)->QErrorMessage::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QErrorMessage_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QErrorMessage_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QErrorMessage_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "lower");
}

void QErrorMessage_LowerDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::lower();
}

void QErrorMessage_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QErrorMessage_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QErrorMessage_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QErrorMessage_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QErrorMessage_MousePressEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QErrorMessage_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QErrorMessage_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QErrorMessage_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QErrorMessage_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QErrorMessage*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QErrorMessage_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QErrorMessage*>(ptr)->QErrorMessage::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QErrorMessage_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "raise");
}

void QErrorMessage_RaiseDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::raise();
}

void QErrorMessage_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "repaint");
}

void QErrorMessage_RepaintDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::repaint();
}

void QErrorMessage_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QErrorMessage_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::setDisabled(disable != 0);
}

void QErrorMessage_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "setFocus");
}

void QErrorMessage_SetFocus2Default(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::setFocus();
}

void QErrorMessage_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QErrorMessage_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::setHidden(hidden != 0);
}

void QErrorMessage_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "show");
}

void QErrorMessage_ShowDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::show();
}

void QErrorMessage_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "showFullScreen");
}

void QErrorMessage_ShowFullScreenDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::showFullScreen();
}

void QErrorMessage_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "showMaximized");
}

void QErrorMessage_ShowMaximizedDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::showMaximized();
}

void QErrorMessage_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "showMinimized");
}

void QErrorMessage_ShowMinimizedDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::showMinimized();
}

void QErrorMessage_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "showNormal");
}

void QErrorMessage_ShowNormalDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::showNormal();
}

void QErrorMessage_TabletEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QErrorMessage_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QErrorMessage_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "update");
}

void QErrorMessage_UpdateDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::update();
}

void QErrorMessage_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "updateMicroFocus");
}

void QErrorMessage_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::updateMicroFocus();
}

void QErrorMessage_WheelEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QErrorMessage_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QErrorMessage_TimerEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QErrorMessage_ChildEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QErrorMessage_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QErrorMessage*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QErrorMessage_CustomEvent(void* ptr, void* event)
{
	static_cast<QErrorMessage*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QErrorMessage_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "deleteLater");
}

void QErrorMessage_DeleteLaterDefault(void* ptr)
{
	static_cast<QErrorMessage*>(ptr)->QErrorMessage::deleteLater();
}

void QErrorMessage_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QErrorMessage*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void* QErrorMessage_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QErrorMessage*>(ptr)->metaObject());
}

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

class MyQFileDialog: public QFileDialog
{
public:
	MyQFileDialog(QWidget *parent, Qt::WindowFlags flags) : QFileDialog(parent, flags) {};
	MyQFileDialog(QWidget *parent, const QString &caption, const QString &directory, const QString &filter) : QFileDialog(parent, caption, directory, filter) {};
	void accept() { callbackQFileDialog_Accept(this); };
	void changeEvent(QEvent * e) { callbackQFileDialog_ChangeEvent(this, e); };
	void Signal_CurrentChanged(const QString & path) { callbackQFileDialog_CurrentChanged(this, const_cast<char*>(path.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_CurrentUrlChanged(const QUrl & url) { callbackQFileDialog_CurrentUrlChanged(this, const_cast<QUrl*>(&url)); };
	void Signal_DirectoryEntered(const QString & directory) { callbackQFileDialog_DirectoryEntered(this, const_cast<char*>(directory.toUtf8().prepend("WHITESPACE").constData()+10)); };
	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) { callbackQFileDialog_FileSelected(this, const_cast<char*>(file.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_FilesSelected(const QStringList & selected) { callbackQFileDialog_FilesSelected(this, const_cast<char*>(selected.join("|").toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_FilterSelected(const QString & filter) { callbackQFileDialog_FilterSelected(this, const_cast<char*>(filter.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQFileDialog_SetVisible(this, visible); };
	void Signal_UrlSelected(const QUrl & url) { callbackQFileDialog_UrlSelected(this, const_cast<QUrl*>(&url)); };
	void closeEvent(QCloseEvent * e) { callbackQFileDialog_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQFileDialog_ContextMenuEvent(this, e); };
	int exec() { return callbackQFileDialog_Exec(this); };
	void keyPressEvent(QKeyEvent * e) { callbackQFileDialog_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQFileDialog_MinimumSizeHint(const_cast<MyQFileDialog*>(this))); };
	void reject() { callbackQFileDialog_Reject(this); };
	void resizeEvent(QResizeEvent * vqr) { callbackQFileDialog_ResizeEvent(this, vqr); };
	void showEvent(QShowEvent * event) { callbackQFileDialog_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQFileDialog_SizeHint(const_cast<MyQFileDialog*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQFileDialog_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQFileDialog_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQFileDialog_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQFileDialog_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQFileDialog_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQFileDialog_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQFileDialog_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQFileDialog_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQFileDialog_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQFileDialog_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQFileDialog_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQFileDialog_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQFileDialog_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQFileDialog_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setWindowModified(bool vbo) { callbackQFileDialog_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQFileDialog_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQFileDialog_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQFileDialog_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQFileDialog_HasHeightForWidth(const_cast<MyQFileDialog*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQFileDialog_HeightForWidth(const_cast<MyQFileDialog*>(this), w); };
	void hide() { callbackQFileDialog_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQFileDialog_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQFileDialog_InputMethodQuery(const_cast<MyQFileDialog*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQFileDialog_KeyReleaseEvent(this, event); };
	void lower() { callbackQFileDialog_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQFileDialog_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQFileDialog_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQFileDialog_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQFileDialog_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQFileDialog_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQFileDialog_Raise(this); };
	void repaint() { callbackQFileDialog_Repaint(this); };
	void setDisabled(bool disable) { callbackQFileDialog_SetDisabled(this, disable); };
	void setFocus() { callbackQFileDialog_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQFileDialog_SetHidden(this, hidden); };
	void show() { callbackQFileDialog_Show(this); };
	void showFullScreen() { callbackQFileDialog_ShowFullScreen(this); };
	void showMaximized() { callbackQFileDialog_ShowMaximized(this); };
	void showMinimized() { callbackQFileDialog_ShowMinimized(this); };
	void showNormal() { callbackQFileDialog_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQFileDialog_TabletEvent(this, event); };
	void update() { callbackQFileDialog_Update(this); };
	void updateMicroFocus() { callbackQFileDialog_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQFileDialog_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQFileDialog_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQFileDialog_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQFileDialog_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQFileDialog_CustomEvent(this, event); };
	void deleteLater() { callbackQFileDialog_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQFileDialog_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFileDialog_MetaObject(const_cast<MyQFileDialog*>(this))); };
};

void* QFileDialog_NewQFileDialog(void* parent, long long flags)
{
	return new MyQFileDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}

long long QFileDialog_AcceptMode(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->acceptMode();
}

char QFileDialog_ConfirmOverwrite(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->confirmOverwrite();
}

char* QFileDialog_DefaultSuffix(void* ptr)
{
	return const_cast<char*>(static_cast<QFileDialog*>(ptr)->defaultSuffix().toUtf8().prepend("WHITESPACE").constData()+10);
}

long long QFileDialog_FileMode(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->fileMode();
}

char QFileDialog_IsNameFilterDetailsVisible(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->isNameFilterDetailsVisible();
}

char QFileDialog_IsReadOnly(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->isReadOnly();
}

long long QFileDialog_Options(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->options();
}

char QFileDialog_ResolveSymlinks(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->resolveSymlinks();
}

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, char* suffix)
{
	static_cast<QFileDialog*>(ptr)->setDefaultSuffix(QString(suffix));
}

void QFileDialog_SetFileMode(void* ptr, long long mode)
{
	static_cast<QFileDialog*>(ptr)->setFileMode(static_cast<QFileDialog::FileMode>(mode));
}

void QFileDialog_SetNameFilterDetailsVisible(void* ptr, char enabled)
{
	static_cast<QFileDialog*>(ptr)->setNameFilterDetailsVisible(enabled != 0);
}

void QFileDialog_SetOptions(void* ptr, long long options)
{
	static_cast<QFileDialog*>(ptr)->setOptions(static_cast<QFileDialog::Option>(options));
}

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_SetSupportedSchemes(void* ptr, char* schemes)
{
	static_cast<QFileDialog*>(ptr)->setSupportedSchemes(QString(schemes).split("|", QString::SkipEmptyParts));
}

void QFileDialog_SetViewMode(void* ptr, long long mode)
{
	static_cast<QFileDialog*>(ptr)->setViewMode(static_cast<QFileDialog::ViewMode>(mode));
}

char* QFileDialog_SupportedSchemes(void* ptr)
{
	return const_cast<char*>(static_cast<QFileDialog*>(ptr)->supportedSchemes().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

long long QFileDialog_ViewMode(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->viewMode();
}

void* QFileDialog_NewQFileDialog2(void* parent, char* caption, char* directory, char* filter)
{
	return new MyQFileDialog(static_cast<QWidget*>(parent), QString(caption), QString(directory), QString(filter));
}

void QFileDialog_Accept(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->accept();
}

void QFileDialog_AcceptDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::accept();
}

void QFileDialog_ChangeEvent(void* ptr, void* e)
{
	static_cast<QFileDialog*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QFileDialog_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::changeEvent(static_cast<QEvent*>(e));
}

void QFileDialog_ConnectCurrentChanged(void* ptr)
{
	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));
}

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, char* path)
{
	static_cast<QFileDialog*>(ptr)->currentChanged(QString(path));
}

void QFileDialog_ConnectCurrentUrlChanged(void* ptr)
{
	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));
}

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));
}

void* QFileDialog_Directory(void* ptr)
{
	return new QDir(static_cast<QFileDialog*>(ptr)->directory());
}

void QFileDialog_ConnectDirectoryEntered(void* ptr)
{
	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));
}

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, char* directory)
{
	static_cast<QFileDialog*>(ptr)->directoryEntered(QString(directory));
}

void* QFileDialog_DirectoryUrl(void* ptr)
{
	return new QUrl(static_cast<QFileDialog*>(ptr)->directoryUrl());
}

void QFileDialog_ConnectDirectoryUrlEntered(void* ptr)
{
	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));
}

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);
}

void QFileDialog_ConnectFileSelected(void* ptr)
{
	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));
}

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, char* file)
{
	static_cast<QFileDialog*>(ptr)->fileSelected(QString(file));
}

void QFileDialog_ConnectFilesSelected(void* ptr)
{
	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));
}

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, char* selected)
{
	static_cast<QFileDialog*>(ptr)->filesSelected(QString(selected).split("|", QString::SkipEmptyParts));
}

long long QFileDialog_Filter(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->filter();
}

void QFileDialog_ConnectFilterSelected(void* ptr)
{
	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));
}

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, char* filter)
{
	static_cast<QFileDialog*>(ptr)->filterSelected(QString(filter));
}

char* QFileDialog_QFileDialog_GetExistingDirectory(void* parent, char* caption, char* dir, long long options)
{
	return const_cast<char*>(QFileDialog::getExistingDirectory(static_cast<QWidget*>(parent), QString(caption), QString(dir), static_cast<QFileDialog::Option>(options)).toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QFileDialog_QFileDialog_GetExistingDirectoryUrl(void* parent, char* caption, void* dir, long long options, char* supportedSchemes)
{
	return new QUrl(QFileDialog::getExistingDirectoryUrl(static_cast<QWidget*>(parent), QString(caption), *static_cast<QUrl*>(dir), static_cast<QFileDialog::Option>(options), QString(supportedSchemes).split("|", QString::SkipEmptyParts)));
}

char* QFileDialog_QFileDialog_GetOpenFileName(void* parent, char* caption, char* dir, char* filter, char* selectedFilter, long long options)
{
	return const_cast<char*>(QFileDialog::getOpenFileName(static_cast<QWidget*>(parent), QString(caption), QString(dir), QString(filter), new QString(selectedFilter), static_cast<QFileDialog::Option>(options)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QFileDialog_QFileDialog_GetOpenFileNames(void* parent, char* caption, char* dir, char* filter, char* selectedFilter, long long options)
{
	return const_cast<char*>(QFileDialog::getOpenFileNames(static_cast<QWidget*>(parent), QString(caption), QString(dir), QString(filter), new QString(selectedFilter), static_cast<QFileDialog::Option>(options)).join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QFileDialog_QFileDialog_GetOpenFileUrl(void* parent, char* caption, void* dir, char* filter, char* selectedFilter, long long options, char* supportedSchemes)
{
	return new QUrl(QFileDialog::getOpenFileUrl(static_cast<QWidget*>(parent), QString(caption), *static_cast<QUrl*>(dir), QString(filter), new QString(selectedFilter), static_cast<QFileDialog::Option>(options), QString(supportedSchemes).split("|", QString::SkipEmptyParts)));
}

char* QFileDialog_QFileDialog_GetSaveFileName(void* parent, char* caption, char* dir, char* filter, char* selectedFilter, long long options)
{
	return const_cast<char*>(QFileDialog::getSaveFileName(static_cast<QWidget*>(parent), QString(caption), QString(dir), QString(filter), new QString(selectedFilter), static_cast<QFileDialog::Option>(options)).toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QFileDialog_QFileDialog_GetSaveFileUrl(void* parent, char* caption, void* dir, char* filter, char* selectedFilter, long long options, char* supportedSchemes)
{
	return new QUrl(QFileDialog::getSaveFileUrl(static_cast<QWidget*>(parent), QString(caption), *static_cast<QUrl*>(dir), QString(filter), new QString(selectedFilter), static_cast<QFileDialog::Option>(options), QString(supportedSchemes).split("|", QString::SkipEmptyParts)));
}

char* QFileDialog_History(void* ptr)
{
	return const_cast<char*>(static_cast<QFileDialog*>(ptr)->history().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QFileDialog_IconProvider(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->iconProvider();
}

void* QFileDialog_ItemDelegate(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->itemDelegate();
}

char* QFileDialog_LabelText(void* ptr, long long label)
{
	return const_cast<char*>(static_cast<QFileDialog*>(ptr)->labelText(static_cast<QFileDialog::DialogLabel>(label)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QFileDialog_MimeTypeFilters(void* ptr)
{
	return const_cast<char*>(static_cast<QFileDialog*>(ptr)->mimeTypeFilters().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QFileDialog_NameFilters(void* ptr)
{
	return const_cast<char*>(static_cast<QFileDialog*>(ptr)->nameFilters().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

void QFileDialog_Open(void* ptr, void* receiver, char* member)
{
	static_cast<QFileDialog*>(ptr)->open(static_cast<QObject*>(receiver), const_cast<const char*>(member));
}

void* QFileDialog_ProxyModel(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->proxyModel();
}

char QFileDialog_RestoreState(void* ptr, char* state)
{
	return static_cast<QFileDialog*>(ptr)->restoreState(QByteArray::fromHex(QString(state).toUtf8()));
}

char* QFileDialog_SaveState(void* ptr)
{
	return const_cast<char*>(static_cast<QFileDialog*>(ptr)->saveState().toHex().prepend("WHITESPACE").constData()+10);
}

void QFileDialog_SelectFile(void* ptr, char* filename)
{
	static_cast<QFileDialog*>(ptr)->selectFile(QString(filename));
}

void QFileDialog_SelectMimeTypeFilter(void* ptr, char* filter)
{
	static_cast<QFileDialog*>(ptr)->selectMimeTypeFilter(QString(filter));
}

void QFileDialog_SelectNameFilter(void* ptr, char* filter)
{
	static_cast<QFileDialog*>(ptr)->selectNameFilter(QString(filter));
}

void QFileDialog_SelectUrl(void* ptr, void* url)
{
	static_cast<QFileDialog*>(ptr)->selectUrl(*static_cast<QUrl*>(url));
}

char* QFileDialog_SelectedFiles(void* ptr)
{
	return const_cast<char*>(static_cast<QFileDialog*>(ptr)->selectedFiles().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QFileDialog_SelectedNameFilter(void* ptr)
{
	return const_cast<char*>(static_cast<QFileDialog*>(ptr)->selectedNameFilter().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QFileDialog_SetDirectory2(void* ptr, void* directory)
{
	static_cast<QFileDialog*>(ptr)->setDirectory(*static_cast<QDir*>(directory));
}

void QFileDialog_SetDirectory(void* ptr, char* directory)
{
	static_cast<QFileDialog*>(ptr)->setDirectory(QString(directory));
}

void QFileDialog_SetDirectoryUrl(void* ptr, void* directory)
{
	static_cast<QFileDialog*>(ptr)->setDirectoryUrl(*static_cast<QUrl*>(directory));
}

void QFileDialog_SetFilter(void* ptr, long long filters)
{
	static_cast<QFileDialog*>(ptr)->setFilter(static_cast<QDir::Filter>(filters));
}

void QFileDialog_SetHistory(void* ptr, char* paths)
{
	static_cast<QFileDialog*>(ptr)->setHistory(QString(paths).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, char* text)
{
	static_cast<QFileDialog*>(ptr)->setLabelText(static_cast<QFileDialog::DialogLabel>(label), QString(text));
}

void QFileDialog_SetMimeTypeFilters(void* ptr, char* filters)
{
	static_cast<QFileDialog*>(ptr)->setMimeTypeFilters(QString(filters).split("|", QString::SkipEmptyParts));
}

void QFileDialog_SetNameFilter(void* ptr, char* filter)
{
	static_cast<QFileDialog*>(ptr)->setNameFilter(QString(filter));
}

void QFileDialog_SetNameFilters(void* ptr, char* filters)
{
	static_cast<QFileDialog*>(ptr)->setNameFilters(QString(filters).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_SetProxyModel(void* ptr, void* proxyModel)
{
	static_cast<QFileDialog*>(ptr)->setProxyModel(static_cast<QAbstractProxyModel*>(proxyModel));
}

void QFileDialog_SetVisible(void* ptr, char visible)
{
	static_cast<QFileDialog*>(ptr)->setVisible(visible != 0);
}

void QFileDialog_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::setVisible(visible != 0);
}

char QFileDialog_TestOption(void* ptr, long long option)
{
	return static_cast<QFileDialog*>(ptr)->testOption(static_cast<QFileDialog::Option>(option));
}

void QFileDialog_ConnectUrlSelected(void* ptr)
{
	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));
}

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_DestroyQFileDialog(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->~QFileDialog();
}

void QFileDialog_CloseEvent(void* ptr, void* e)
{
	static_cast<QFileDialog*>(ptr)->closeEvent(static_cast<QCloseEvent*>(e));
}

void QFileDialog_CloseEventDefault(void* ptr, void* e)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::closeEvent(static_cast<QCloseEvent*>(e));
}

void QFileDialog_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QFileDialog*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QFileDialog_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

int QFileDialog_Exec(void* ptr)
{
	int returnArg;
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "exec", Q_RETURN_ARG(int, returnArg));
	return returnArg;
}

int QFileDialog_ExecDefault(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->QFileDialog::exec();
}

void QFileDialog_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QFileDialog*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QFileDialog_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void* QFileDialog_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFileDialog*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QFileDialog_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFileDialog*>(ptr)->QFileDialog::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QFileDialog_Reject(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "reject");
}

void QFileDialog_RejectDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::reject();
}

void QFileDialog_ResizeEvent(void* ptr, void* vqr)
{
	static_cast<QFileDialog*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QFileDialog_ResizeEventDefault(void* ptr, void* vqr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QFileDialog_ShowEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QFileDialog_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::showEvent(static_cast<QShowEvent*>(event));
}

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

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

void QFileDialog_ActionEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QFileDialog_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::actionEvent(static_cast<QActionEvent*>(event));
}

void QFileDialog_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QFileDialog_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QFileDialog_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QFileDialog_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QFileDialog_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QFileDialog_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QFileDialog_DropEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QFileDialog_DropEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::dropEvent(static_cast<QDropEvent*>(event));
}

void QFileDialog_EnterEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QFileDialog_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::enterEvent(static_cast<QEvent*>(event));
}

void QFileDialog_FocusInEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QFileDialog_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QFileDialog_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QFileDialog_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QFileDialog_HideEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QFileDialog_HideEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::hideEvent(static_cast<QHideEvent*>(event));
}

void QFileDialog_LeaveEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QFileDialog_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::leaveEvent(static_cast<QEvent*>(event));
}

void QFileDialog_MoveEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QFileDialog_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::moveEvent(static_cast<QMoveEvent*>(event));
}

void QFileDialog_PaintEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QFileDialog_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::paintEvent(static_cast<QPaintEvent*>(event));
}

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

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

void QFileDialog_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QFileDialog_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::setStyleSheet(QString(styleSheet));
}

void QFileDialog_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QFileDialog_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::setWindowModified(vbo != 0);
}

void QFileDialog_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QFileDialog_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::setWindowTitle(QString(vqs));
}

char QFileDialog_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QFileDialog_CloseDefault(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->QFileDialog::close();
}

char QFileDialog_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QFileDialog*>(ptr)->focusNextPrevChild(next != 0);
}

char QFileDialog_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QFileDialog*>(ptr)->QFileDialog::focusNextPrevChild(next != 0);
}

char QFileDialog_HasHeightForWidth(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->hasHeightForWidth();
}

char QFileDialog_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QFileDialog*>(ptr)->QFileDialog::hasHeightForWidth();
}

int QFileDialog_HeightForWidth(void* ptr, int w)
{
	return static_cast<QFileDialog*>(ptr)->heightForWidth(w);
}

int QFileDialog_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QFileDialog*>(ptr)->QFileDialog::heightForWidth(w);
}

void QFileDialog_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "hide");
}

void QFileDialog_HideDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::hide();
}

void QFileDialog_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QFileDialog_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QFileDialog_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QFileDialog*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QFileDialog_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QFileDialog*>(ptr)->QFileDialog::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QFileDialog_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QFileDialog_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QFileDialog_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "lower");
}

void QFileDialog_LowerDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::lower();
}

void QFileDialog_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QFileDialog_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QFileDialog_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QFileDialog_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QFileDialog_MousePressEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QFileDialog_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QFileDialog_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QFileDialog_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QFileDialog_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QFileDialog*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QFileDialog_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QFileDialog*>(ptr)->QFileDialog::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QFileDialog_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "raise");
}

void QFileDialog_RaiseDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::raise();
}

void QFileDialog_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "repaint");
}

void QFileDialog_RepaintDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::repaint();
}

void QFileDialog_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QFileDialog_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::setDisabled(disable != 0);
}

void QFileDialog_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "setFocus");
}

void QFileDialog_SetFocus2Default(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::setFocus();
}

void QFileDialog_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QFileDialog_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::setHidden(hidden != 0);
}

void QFileDialog_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "show");
}

void QFileDialog_ShowDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::show();
}

void QFileDialog_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "showFullScreen");
}

void QFileDialog_ShowFullScreenDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::showFullScreen();
}

void QFileDialog_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "showMaximized");
}

void QFileDialog_ShowMaximizedDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::showMaximized();
}

void QFileDialog_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "showMinimized");
}

void QFileDialog_ShowMinimizedDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::showMinimized();
}

void QFileDialog_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "showNormal");
}

void QFileDialog_ShowNormalDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::showNormal();
}

void QFileDialog_TabletEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QFileDialog_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QFileDialog_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "update");
}

void QFileDialog_UpdateDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::update();
}

void QFileDialog_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "updateMicroFocus");
}

void QFileDialog_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::updateMicroFocus();
}

void QFileDialog_WheelEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QFileDialog_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QFileDialog_TimerEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QFileDialog_ChildEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QFileDialog_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QFileDialog*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QFileDialog_CustomEvent(void* ptr, void* event)
{
	static_cast<QFileDialog*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QFileDialog_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "deleteLater");
}

void QFileDialog_DeleteLaterDefault(void* ptr)
{
	static_cast<QFileDialog*>(ptr)->QFileDialog::deleteLater();
}

void QFileDialog_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QFileDialog*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void* QFileDialog_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QFileDialog*>(ptr)->metaObject());
}

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

class MyQFileIconProvider: public QFileIconProvider
{
public:
	MyQFileIconProvider() : QFileIconProvider() {};
	QIcon icon(QFileIconProvider::IconType ty) const { return *static_cast<QIcon*>(callbackQFileIconProvider_Icon(const_cast<MyQFileIconProvider*>(this), ty)); };
	QIcon icon(const QFileInfo & info) const { return *static_cast<QIcon*>(callbackQFileIconProvider_Icon2(const_cast<MyQFileIconProvider*>(this), const_cast<QFileInfo*>(&info))); };
	QString type(const QFileInfo & info) const { return QString(callbackQFileIconProvider_Type(const_cast<MyQFileIconProvider*>(this), const_cast<QFileInfo*>(&info))); };
	 ~MyQFileIconProvider() { callbackQFileIconProvider_DestroyQFileIconProvider(this); };
};

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));
}

char* QFileIconProvider_Type(void* ptr, void* info)
{
	return const_cast<char*>(static_cast<QFileIconProvider*>(ptr)->type(*static_cast<QFileInfo*>(info)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QFileIconProvider_TypeDefault(void* ptr, void* info)
{
	return const_cast<char*>(static_cast<QFileIconProvider*>(ptr)->QFileIconProvider::type(*static_cast<QFileInfo*>(info)).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QFileIconProvider_DestroyQFileIconProvider(void* ptr)
{
	static_cast<QFileIconProvider*>(ptr)->~QFileIconProvider();
}

void QFileIconProvider_DestroyQFileIconProviderDefault(void* ptr)
{

}

int QFileSystemModel_FilePathRole_Type()
{
	return QFileSystemModel::FilePathRole;
}

int QFileSystemModel_FileNameRole_Type()
{
	return QFileSystemModel::FileNameRole;
}

int QFileSystemModel_FilePermissions_Type()
{
	return QFileSystemModel::FilePermissions;
}

class MyQFileSystemModel: public QFileSystemModel
{
public:
	MyQFileSystemModel(QObject *parent) : QFileSystemModel(parent) {};
	void Signal_DirectoryLoaded(const QString & path) { callbackQFileSystemModel_DirectoryLoaded(this, const_cast<char*>(path.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_FileRenamed(const QString & path, const QString & oldName, const QString & newName) { callbackQFileSystemModel_FileRenamed(this, const_cast<char*>(path.toUtf8().prepend("WHITESPACE").constData()+10), const_cast<char*>(oldName.toUtf8().prepend("WHITESPACE").constData()+10), const_cast<char*>(newName.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_RootPathChanged(const QString & newPath) { callbackQFileSystemModel_RootPathChanged(this, const_cast<char*>(newPath.toUtf8().prepend("WHITESPACE").constData()+10)); };
	QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQFileSystemModel_Buddy(const_cast<MyQFileSystemModel*>(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<MyQFileSystemModel*>(this), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
	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; };
	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); };
	bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQFileSystemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
	QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQFileSystemModel_Span(const_cast<MyQFileSystemModel*>(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<MyQFileSystemModel*>(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 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<MyQFileSystemModel*>(this))); };
};

void* QFileSystemModel_FileInfo(void* ptr, void* index)
{
	return new QFileInfo(static_cast<QFileSystemModel*>(ptr)->fileInfo(*static_cast<QModelIndex*>(index)));
}

char QFileSystemModel_IsReadOnly(void* ptr)
{
	return static_cast<QFileSystemModel*>(ptr)->isReadOnly();
}

char QFileSystemModel_NameFilterDisables(void* ptr)
{
	return static_cast<QFileSystemModel*>(ptr)->nameFilterDisables();
}

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_SetNameFilterDisables(void* ptr, char enable)
{
	static_cast<QFileSystemModel*>(ptr)->setNameFilterDisables(enable != 0);
}

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_NewQFileSystemModel(void* parent)
{
	return new MyQFileSystemModel(static_cast<QObject*>(parent));
}

char QFileSystemModel_CanFetchMore(void* ptr, void* parent)
{
	return static_cast<QFileSystemModel*>(ptr)->canFetchMore(*static_cast<QModelIndex*>(parent));
}

int QFileSystemModel_ColumnCount(void* ptr, void* parent)
{
	return static_cast<QFileSystemModel*>(ptr)->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_ConnectDirectoryLoaded(void* ptr)
{
	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));
}

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, char* path)
{
	static_cast<QFileSystemModel*>(ptr)->directoryLoaded(QString(path));
}

char QFileSystemModel_DropMimeData(void* ptr, void* data, long long action, int row, int column, void* parent)
{
	return static_cast<QFileSystemModel*>(ptr)->dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}

char QFileSystemModel_Event(void* ptr, void* event)
{
	return static_cast<QFileSystemModel*>(ptr)->event(static_cast<QEvent*>(event));
}

void QFileSystemModel_FetchMore(void* ptr, void* parent)
{
	static_cast<QFileSystemModel*>(ptr)->fetchMore(*static_cast<QModelIndex*>(parent));
}

void* QFileSystemModel_FileIcon(void* ptr, void* index)
{
	return new QIcon(static_cast<QFileSystemModel*>(ptr)->fileIcon(*static_cast<QModelIndex*>(index)));
}

char* QFileSystemModel_FileName(void* ptr, void* index)
{
	return const_cast<char*>(static_cast<QFileSystemModel*>(ptr)->fileName(*static_cast<QModelIndex*>(index)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QFileSystemModel_FilePath(void* ptr, void* index)
{
	return const_cast<char*>(static_cast<QFileSystemModel*>(ptr)->filePath(*static_cast<QModelIndex*>(index)).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QFileSystemModel_ConnectFileRenamed(void* ptr)
{
	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));
}

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, char* path, char* oldName, char* newName)
{
	static_cast<QFileSystemModel*>(ptr)->fileRenamed(QString(path), QString(oldName), QString(newName));
}

long long QFileSystemModel_Filter(void* ptr)
{
	return static_cast<QFileSystemModel*>(ptr)->filter();
}

long long QFileSystemModel_Flags(void* ptr, void* index)
{
	return static_cast<QFileSystemModel*>(ptr)->flags(*static_cast<QModelIndex*>(index));
}

char QFileSystemModel_HasChildren(void* ptr, void* parent)
{
	return static_cast<QFileSystemModel*>(ptr)->hasChildren(*static_cast<QModelIndex*>(parent));
}

void* QFileSystemModel_HeaderData(void* ptr, int section, long long orientation, int role)
{
	return new QVariant(static_cast<QFileSystemModel*>(ptr)->headerData(section, static_cast<Qt::Orientation>(orientation), role));
}

void* QFileSystemModel_IconProvider(void* ptr)
{
	return static_cast<QFileSystemModel*>(ptr)->iconProvider();
}

void* QFileSystemModel_Index2(void* ptr, char* path, int column)
{
	return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->index(QString(path), column));
}

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)));
}

char QFileSystemModel_IsDir(void* ptr, void* index)
{
	return static_cast<QFileSystemModel*>(ptr)->isDir(*static_cast<QModelIndex*>(index));
}

void* QFileSystemModel_LastModified(void* ptr, void* index)
{
	return new QDateTime(static_cast<QFileSystemModel*>(ptr)->lastModified(*static_cast<QModelIndex*>(index)));
}

char* QFileSystemModel_MimeTypes(void* ptr)
{
	return const_cast<char*>(static_cast<QFileSystemModel*>(ptr)->mimeTypes().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QFileSystemModel_Mkdir(void* ptr, void* parent, char* name)
{
	return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->mkdir(*static_cast<QModelIndex*>(parent), QString(name)));
}

void* QFileSystemModel_MyComputer(void* ptr, int role)
{
	return new QVariant(static_cast<QFileSystemModel*>(ptr)->myComputer(role));
}

char* QFileSystemModel_NameFilters(void* ptr)
{
	return const_cast<char*>(static_cast<QFileSystemModel*>(ptr)->nameFilters().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QFileSystemModel_Parent(void* ptr, void* index)
{
	return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->parent(*static_cast<QModelIndex*>(index)));
}

void* QFileSystemModel_RootDirectory(void* ptr)
{
	return new QDir(static_cast<QFileSystemModel*>(ptr)->rootDirectory());
}

char* QFileSystemModel_RootPath(void* ptr)
{
	return const_cast<char*>(static_cast<QFileSystemModel*>(ptr)->rootPath().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QFileSystemModel_ConnectRootPathChanged(void* ptr)
{
	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));
}

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, char* newPath)
{
	static_cast<QFileSystemModel*>(ptr)->rootPathChanged(QString(newPath));
}

int QFileSystemModel_RowCount(void* ptr, void* parent)
{
	return static_cast<QFileSystemModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}

char QFileSystemModel_SetData(void* ptr, void* idx, void* value, int role)
{
	return static_cast<QFileSystemModel*>(ptr)->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_SetNameFilters(void* ptr, char* filters)
{
	static_cast<QFileSystemModel*>(ptr)->setNameFilters(QString(filters).split("|", QString::SkipEmptyParts));
}

void* QFileSystemModel_SetRootPath(void* ptr, char* newPath)
{
	return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->setRootPath(QString(newPath)));
}

void* QFileSystemModel_Sibling(void* ptr, int row, int column, void* idx)
{
	return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->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_Sort(void* ptr, int column, long long order)
{
	static_cast<QFileSystemModel*>(ptr)->sort(column, static_cast<Qt::SortOrder>(order));
}

long long QFileSystemModel_SupportedDropActions(void* ptr)
{
	return static_cast<QFileSystemModel*>(ptr)->supportedDropActions();
}

void QFileSystemModel_TimerEvent(void* ptr, void* event)
{
	static_cast<QFileSystemModel*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

char* QFileSystemModel_Type(void* ptr, void* index)
{
	return const_cast<char*>(static_cast<QFileSystemModel*>(ptr)->type(*static_cast<QModelIndex*>(index)).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QFileSystemModel_DestroyQFileSystemModel(void* ptr)
{
	static_cast<QFileSystemModel*>(ptr)->~QFileSystemModel();
}

void* QFileSystemModel_Buddy(void* ptr, void* index)
{
	return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->buddy(*static_cast<QModelIndex*>(index)));
}

void* QFileSystemModel_BuddyDefault(void* ptr, void* index)
{
	return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::buddy(*static_cast<QModelIndex*>(index)));
}

char QFileSystemModel_CanDropMimeData(void* ptr, void* data, long long action, int row, int column, void* parent)
{
	return static_cast<QFileSystemModel*>(ptr)->canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}

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_InsertColumns(void* ptr, int column, int count, void* parent)
{
	return static_cast<QFileSystemModel*>(ptr)->insertColumns(column, count, *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_InsertRows(void* ptr, int row, int count, void* parent)
{
	return static_cast<QFileSystemModel*>(ptr)->insertRows(row, 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));
}

char QFileSystemModel_MoveColumns(void* ptr, void* sourceParent, int sourceColumn, int count, void* destinationParent, int destinationChild)
{
	return static_cast<QFileSystemModel*>(ptr)->moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}

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_MoveRows(void* ptr, void* sourceParent, int sourceRow, int count, void* destinationParent, int destinationChild)
{
	return static_cast<QFileSystemModel*>(ptr)->moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, 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_RemoveColumns(void* ptr, int column, int count, void* parent)
{
	return static_cast<QFileSystemModel*>(ptr)->removeColumns(column, count, *static_cast<QModelIndex*>(parent));
}

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_RemoveRows(void* ptr, int row, int count, void* parent)
{
	return static_cast<QFileSystemModel*>(ptr)->removeRows(row, 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_ResetInternalData(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileSystemModel*>(ptr), "resetInternalData");
}

void QFileSystemModel_ResetInternalDataDefault(void* ptr)
{
	static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::resetInternalData();
}

void QFileSystemModel_Revert(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileSystemModel*>(ptr), "revert");
}

void QFileSystemModel_RevertDefault(void* ptr)
{
	static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::revert();
}

char QFileSystemModel_SetHeaderData(void* ptr, int section, long long orientation, void* value, int role)
{
	return static_cast<QFileSystemModel*>(ptr)->setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
}

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);
}

void* QFileSystemModel_Span(void* ptr, void* index)
{
	return ({ QSize tmpValue = static_cast<QFileSystemModel*>(ptr)->span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
}

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_Submit(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QFileSystemModel*>(ptr), "submit", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QFileSystemModel_SubmitDefault(void* ptr)
{
	return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::submit();
}

long long QFileSystemModel_SupportedDragActions(void* ptr)
{
	return static_cast<QFileSystemModel*>(ptr)->supportedDragActions();
}

long long QFileSystemModel_SupportedDragActionsDefault(void* ptr)
{
	return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::supportedDragActions();
}

void QFileSystemModel_ChildEvent(void* ptr, void* event)
{
	static_cast<QFileSystemModel*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QFileSystemModel_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QFileSystemModel*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QFileSystemModel_CustomEvent(void* ptr, void* event)
{
	static_cast<QFileSystemModel*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QFileSystemModel_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFileSystemModel*>(ptr), "deleteLater");
}

void QFileSystemModel_DeleteLaterDefault(void* ptr)
{
	static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::deleteLater();
}

void QFileSystemModel_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QFileSystemModel*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QFileSystemModel_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QFileSystemModel*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QFileSystemModel_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QFileSystemModel_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QFileSystemModel*>(ptr)->metaObject());
}

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

class MyQFocusFrame: public QFocusFrame
{
public:
	MyQFocusFrame(QWidget *parent) : QFocusFrame(parent) {};
	void paintEvent(QPaintEvent * vqp) { callbackQFocusFrame_PaintEvent(this, vqp); };
	void actionEvent(QActionEvent * event) { callbackQFocusFrame_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQFocusFrame_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQFocusFrame_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQFocusFrame_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQFocusFrame_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQFocusFrame_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQFocusFrame_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQFocusFrame_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQFocusFrame_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQFocusFrame_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQFocusFrame_MinimumSizeHint(const_cast<MyQFocusFrame*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQFocusFrame_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQFocusFrame_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQFocusFrame_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQFocusFrame_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQFocusFrame_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQFocusFrame_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQFocusFrame_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQFocusFrame_SizeHint(const_cast<MyQFocusFrame*>(this))); };
	void changeEvent(QEvent * event) { callbackQFocusFrame_ChangeEvent(this, event); };
	bool close() { return callbackQFocusFrame_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQFocusFrame_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQFocusFrame_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQFocusFrame_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQFocusFrame_HasHeightForWidth(const_cast<MyQFocusFrame*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQFocusFrame_HeightForWidth(const_cast<MyQFocusFrame*>(this), w); };
	void hide() { callbackQFocusFrame_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQFocusFrame_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQFocusFrame_InputMethodQuery(const_cast<MyQFocusFrame*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQFocusFrame_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQFocusFrame_KeyReleaseEvent(this, event); };
	void lower() { callbackQFocusFrame_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQFocusFrame_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQFocusFrame_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQFocusFrame_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQFocusFrame_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQFocusFrame_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQFocusFrame_Raise(this); };
	void repaint() { callbackQFocusFrame_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQFocusFrame_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQFocusFrame_SetDisabled(this, disable); };
	void setFocus() { callbackQFocusFrame_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQFocusFrame_SetHidden(this, hidden); };
	void show() { callbackQFocusFrame_Show(this); };
	void showFullScreen() { callbackQFocusFrame_ShowFullScreen(this); };
	void showMaximized() { callbackQFocusFrame_ShowMaximized(this); };
	void showMinimized() { callbackQFocusFrame_ShowMinimized(this); };
	void showNormal() { callbackQFocusFrame_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQFocusFrame_TabletEvent(this, event); };
	void update() { callbackQFocusFrame_Update(this); };
	void updateMicroFocus() { callbackQFocusFrame_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQFocusFrame_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQFocusFrame_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQFocusFrame_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQFocusFrame_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQFocusFrame_CustomEvent(this, event); };
	void deleteLater() { callbackQFocusFrame_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQFocusFrame_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFocusFrame_MetaObject(const_cast<MyQFocusFrame*>(this))); };
};

void* QFocusFrame_NewQFocusFrame(void* parent)
{
	return new MyQFocusFrame(static_cast<QWidget*>(parent));
}

char QFocusFrame_Event(void* ptr, void* e)
{
	return static_cast<QFocusFrame*>(ptr)->event(static_cast<QEvent*>(e));
}

char QFocusFrame_EventFilter(void* ptr, void* o, void* e)
{
	return static_cast<QFocusFrame*>(ptr)->eventFilter(static_cast<QObject*>(o), static_cast<QEvent*>(e));
}

void QFocusFrame_InitStyleOption(void* ptr, void* option)
{
	static_cast<QFocusFrame*>(ptr)->initStyleOption(static_cast<QStyleOption*>(option));
}

void QFocusFrame_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QFocusFrame*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QFocusFrame_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::paintEvent(static_cast<QPaintEvent*>(vqp));
}

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_ActionEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QFocusFrame_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::actionEvent(static_cast<QActionEvent*>(event));
}

void QFocusFrame_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QFocusFrame_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QFocusFrame_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QFocusFrame_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QFocusFrame_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QFocusFrame_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QFocusFrame_DropEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QFocusFrame_DropEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::dropEvent(static_cast<QDropEvent*>(event));
}

void QFocusFrame_EnterEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QFocusFrame_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::enterEvent(static_cast<QEvent*>(event));
}

void QFocusFrame_FocusInEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QFocusFrame_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QFocusFrame_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QFocusFrame_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QFocusFrame_HideEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QFocusFrame_HideEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::hideEvent(static_cast<QHideEvent*>(event));
}

void QFocusFrame_LeaveEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QFocusFrame_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::leaveEvent(static_cast<QEvent*>(event));
}

void* QFocusFrame_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFocusFrame*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QFocusFrame_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFocusFrame*>(ptr)->QFocusFrame::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QFocusFrame_MoveEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QFocusFrame_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QFocusFrame_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QFocusFrame_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::setStyleSheet(QString(styleSheet));
}

void QFocusFrame_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QFocusFrame_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::setVisible(visible != 0);
}

void QFocusFrame_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QFocusFrame_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::setWindowModified(vbo != 0);
}

void QFocusFrame_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QFocusFrame_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::setWindowTitle(QString(vqs));
}

void QFocusFrame_ShowEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QFocusFrame_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::showEvent(static_cast<QShowEvent*>(event));
}

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

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

void QFocusFrame_ChangeEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QFocusFrame_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::changeEvent(static_cast<QEvent*>(event));
}

char QFocusFrame_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QFocusFrame_CloseDefault(void* ptr)
{
	return static_cast<QFocusFrame*>(ptr)->QFocusFrame::close();
}

void QFocusFrame_CloseEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QFocusFrame_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::closeEvent(static_cast<QCloseEvent*>(event));
}

void QFocusFrame_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QFocusFrame_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QFocusFrame_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QFocusFrame*>(ptr)->focusNextPrevChild(next != 0);
}

char QFocusFrame_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QFocusFrame*>(ptr)->QFocusFrame::focusNextPrevChild(next != 0);
}

char QFocusFrame_HasHeightForWidth(void* ptr)
{
	return static_cast<QFocusFrame*>(ptr)->hasHeightForWidth();
}

char QFocusFrame_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QFocusFrame*>(ptr)->QFocusFrame::hasHeightForWidth();
}

int QFocusFrame_HeightForWidth(void* ptr, int w)
{
	return static_cast<QFocusFrame*>(ptr)->heightForWidth(w);
}

int QFocusFrame_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QFocusFrame*>(ptr)->QFocusFrame::heightForWidth(w);
}

void QFocusFrame_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "hide");
}

void QFocusFrame_HideDefault(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::hide();
}

void QFocusFrame_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QFocusFrame_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QFocusFrame_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QFocusFrame*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QFocusFrame_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QFocusFrame*>(ptr)->QFocusFrame::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QFocusFrame_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QFocusFrame_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QFocusFrame_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QFocusFrame_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QFocusFrame_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "lower");
}

void QFocusFrame_LowerDefault(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::lower();
}

void QFocusFrame_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QFocusFrame_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QFocusFrame_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QFocusFrame_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QFocusFrame_MousePressEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QFocusFrame_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QFocusFrame_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QFocusFrame_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QFocusFrame_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QFocusFrame*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QFocusFrame_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QFocusFrame*>(ptr)->QFocusFrame::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QFocusFrame_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "raise");
}

void QFocusFrame_RaiseDefault(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::raise();
}

void QFocusFrame_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "repaint");
}

void QFocusFrame_RepaintDefault(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::repaint();
}

void QFocusFrame_ResizeEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QFocusFrame_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QFocusFrame_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QFocusFrame_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::setDisabled(disable != 0);
}

void QFocusFrame_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "setFocus");
}

void QFocusFrame_SetFocus2Default(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::setFocus();
}

void QFocusFrame_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QFocusFrame_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::setHidden(hidden != 0);
}

void QFocusFrame_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "show");
}

void QFocusFrame_ShowDefault(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::show();
}

void QFocusFrame_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "showFullScreen");
}

void QFocusFrame_ShowFullScreenDefault(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::showFullScreen();
}

void QFocusFrame_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "showMaximized");
}

void QFocusFrame_ShowMaximizedDefault(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::showMaximized();
}

void QFocusFrame_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "showMinimized");
}

void QFocusFrame_ShowMinimizedDefault(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::showMinimized();
}

void QFocusFrame_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "showNormal");
}

void QFocusFrame_ShowNormalDefault(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::showNormal();
}

void QFocusFrame_TabletEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QFocusFrame_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QFocusFrame_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "update");
}

void QFocusFrame_UpdateDefault(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::update();
}

void QFocusFrame_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "updateMicroFocus");
}

void QFocusFrame_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::updateMicroFocus();
}

void QFocusFrame_WheelEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QFocusFrame_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QFocusFrame_TimerEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QFocusFrame_ChildEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QFocusFrame_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QFocusFrame*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QFocusFrame_CustomEvent(void* ptr, void* event)
{
	static_cast<QFocusFrame*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QFocusFrame_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "deleteLater");
}

void QFocusFrame_DeleteLaterDefault(void* ptr)
{
	static_cast<QFocusFrame*>(ptr)->QFocusFrame::deleteLater();
}

void QFocusFrame_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QFocusFrame*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void* QFocusFrame_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QFocusFrame*>(ptr)->metaObject());
}

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

class MyQFontComboBox: public QFontComboBox
{
public:
	MyQFontComboBox(QWidget *parent) : QFontComboBox(parent) {};
	void setCurrentFont(const QFont & f) { callbackQFontComboBox_SetCurrentFont(this, const_cast<QFont*>(&f)); };
	void Signal_CurrentFontChanged(const QFont & font) { callbackQFontComboBox_CurrentFontChanged(this, const_cast<QFont*>(&font)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQFontComboBox_SizeHint(const_cast<MyQFontComboBox*>(this))); };
	void setCurrentIndex(int index) { callbackQFontComboBox_SetCurrentIndex(this, index); };
	void setCurrentText(const QString & text) { callbackQFontComboBox_SetCurrentText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void changeEvent(QEvent * e) { callbackQFontComboBox_ChangeEvent(this, e); };
	void clear() { callbackQFontComboBox_Clear(this); };
	void clearEditText() { callbackQFontComboBox_ClearEditText(this); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQFontComboBox_ContextMenuEvent(this, e); };
	void focusInEvent(QFocusEvent * e) { callbackQFontComboBox_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQFontComboBox_FocusOutEvent(this, e); };
	void hideEvent(QHideEvent * e) { callbackQFontComboBox_HideEvent(this, e); };
	void hidePopup() { callbackQFontComboBox_HidePopup(this); };
	void inputMethodEvent(QInputMethodEvent * e) { callbackQFontComboBox_InputMethodEvent(this, e); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQFontComboBox_InputMethodQuery(const_cast<MyQFontComboBox*>(this), query)); };
	void keyPressEvent(QKeyEvent * e) { callbackQFontComboBox_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQFontComboBox_KeyReleaseEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQFontComboBox_MinimumSizeHint(const_cast<MyQFontComboBox*>(this))); };
	void mousePressEvent(QMouseEvent * e) { callbackQFontComboBox_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQFontComboBox_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQFontComboBox_PaintEvent(this, e); };
	void resizeEvent(QResizeEvent * e) { callbackQFontComboBox_ResizeEvent(this, e); };
	void setEditText(const QString & text) { callbackQFontComboBox_SetEditText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * e) { callbackQFontComboBox_ShowEvent(this, e); };
	void showPopup() { callbackQFontComboBox_ShowPopup(this); };
	void wheelEvent(QWheelEvent * e) { callbackQFontComboBox_WheelEvent(this, e); };
	void actionEvent(QActionEvent * event) { callbackQFontComboBox_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQFontComboBox_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQFontComboBox_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQFontComboBox_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQFontComboBox_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQFontComboBox_EnterEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQFontComboBox_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQFontComboBox_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQFontComboBox_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQFontComboBox_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQFontComboBox_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQFontComboBox_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQFontComboBox_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQFontComboBox_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQFontComboBox_CloseEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQFontComboBox_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQFontComboBox_HasHeightForWidth(const_cast<MyQFontComboBox*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQFontComboBox_HeightForWidth(const_cast<MyQFontComboBox*>(this), w); };
	void hide() { callbackQFontComboBox_Hide(this); };
	void lower() { callbackQFontComboBox_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQFontComboBox_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQFontComboBox_MouseMoveEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQFontComboBox_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQFontComboBox_Raise(this); };
	void repaint() { callbackQFontComboBox_Repaint(this); };
	void setDisabled(bool disable) { callbackQFontComboBox_SetDisabled(this, disable); };
	void setFocus() { callbackQFontComboBox_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQFontComboBox_SetHidden(this, hidden); };
	void show() { callbackQFontComboBox_Show(this); };
	void showFullScreen() { callbackQFontComboBox_ShowFullScreen(this); };
	void showMaximized() { callbackQFontComboBox_ShowMaximized(this); };
	void showMinimized() { callbackQFontComboBox_ShowMinimized(this); };
	void showNormal() { callbackQFontComboBox_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQFontComboBox_TabletEvent(this, event); };
	void update() { callbackQFontComboBox_Update(this); };
	void updateMicroFocus() { callbackQFontComboBox_UpdateMicroFocus(this); };
	void timerEvent(QTimerEvent * event) { callbackQFontComboBox_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQFontComboBox_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQFontComboBox_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQFontComboBox_CustomEvent(this, event); };
	void deleteLater() { callbackQFontComboBox_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQFontComboBox_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQFontComboBox_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFontComboBox_MetaObject(const_cast<MyQFontComboBox*>(this))); };
};

void* QFontComboBox_CurrentFont(void* ptr)
{
	return new QFont(static_cast<QFontComboBox*>(ptr)->currentFont());
}

long long QFontComboBox_FontFilters(void* ptr)
{
	return static_cast<QFontComboBox*>(ptr)->fontFilters();
}

void QFontComboBox_SetCurrentFont(void* ptr, void* f)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setCurrentFont", Q_ARG(QFont, *static_cast<QFont*>(f)));
}

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));
}

long long QFontComboBox_WritingSystem(void* ptr)
{
	return static_cast<QFontComboBox*>(ptr)->writingSystem();
}

void* QFontComboBox_NewQFontComboBox(void* parent)
{
	return new MyQFontComboBox(static_cast<QWidget*>(parent));
}

void QFontComboBox_ConnectCurrentFontChanged(void* ptr)
{
	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));
}

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));
}

char QFontComboBox_Event(void* ptr, void* e)
{
	return static_cast<QFontComboBox*>(ptr)->event(static_cast<QEvent*>(e));
}

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

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

void QFontComboBox_DestroyQFontComboBox(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->~QFontComboBox();
}

void QFontComboBox_SetCurrentIndex(void* ptr, int index)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setCurrentIndex", Q_ARG(int, index));
}

void QFontComboBox_SetCurrentIndexDefault(void* ptr, int index)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::setCurrentIndex(index);
}

void QFontComboBox_SetCurrentText(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setCurrentText", Q_ARG(QString, QString(text)));
}

void QFontComboBox_SetCurrentTextDefault(void* ptr, char* text)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::setCurrentText(QString(text));
}

void QFontComboBox_ChangeEvent(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QFontComboBox_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::changeEvent(static_cast<QEvent*>(e));
}

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

void QFontComboBox_ClearDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::clear();
}

void QFontComboBox_ClearEditText(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "clearEditText");
}

void QFontComboBox_ClearEditTextDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::clearEditText();
}

void QFontComboBox_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QFontComboBox_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QFontComboBox_FocusInEvent(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(e));
}

void QFontComboBox_FocusInEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::focusInEvent(static_cast<QFocusEvent*>(e));
}

void QFontComboBox_FocusOutEvent(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QFontComboBox_FocusOutEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QFontComboBox_HideEvent(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->hideEvent(static_cast<QHideEvent*>(e));
}

void QFontComboBox_HideEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::hideEvent(static_cast<QHideEvent*>(e));
}

void QFontComboBox_HidePopup(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->hidePopup();
}

void QFontComboBox_HidePopupDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::hidePopup();
}

void QFontComboBox_InputMethodEvent(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(e));
}

void QFontComboBox_InputMethodEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::inputMethodEvent(static_cast<QInputMethodEvent*>(e));
}

void* QFontComboBox_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QFontComboBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QFontComboBox_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QFontComboBox*>(ptr)->QFontComboBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QFontComboBox_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QFontComboBox_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QFontComboBox_KeyReleaseEvent(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QFontComboBox_KeyReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void* QFontComboBox_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFontComboBox*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QFontComboBox_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFontComboBox*>(ptr)->QFontComboBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QFontComboBox_MousePressEvent(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QFontComboBox_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QFontComboBox_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QFontComboBox_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

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

void QFontComboBox_PaintEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::paintEvent(static_cast<QPaintEvent*>(e));
}

void QFontComboBox_ResizeEvent(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(e));
}

void QFontComboBox_ResizeEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::resizeEvent(static_cast<QResizeEvent*>(e));
}

void QFontComboBox_SetEditText(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setEditText", Q_ARG(QString, QString(text)));
}

void QFontComboBox_SetEditTextDefault(void* ptr, char* text)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::setEditText(QString(text));
}

void QFontComboBox_ShowEvent(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->showEvent(static_cast<QShowEvent*>(e));
}

void QFontComboBox_ShowEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::showEvent(static_cast<QShowEvent*>(e));
}

void QFontComboBox_ShowPopup(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->showPopup();
}

void QFontComboBox_ShowPopupDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::showPopup();
}

void QFontComboBox_WheelEvent(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QFontComboBox_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QFontComboBox_ActionEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QFontComboBox_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::actionEvent(static_cast<QActionEvent*>(event));
}

void QFontComboBox_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QFontComboBox_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QFontComboBox_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QFontComboBox_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QFontComboBox_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QFontComboBox_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QFontComboBox_DropEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QFontComboBox_DropEventDefault(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::dropEvent(static_cast<QDropEvent*>(event));
}

void QFontComboBox_EnterEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QFontComboBox_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::enterEvent(static_cast<QEvent*>(event));
}

void QFontComboBox_LeaveEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QFontComboBox_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::leaveEvent(static_cast<QEvent*>(event));
}

void QFontComboBox_MoveEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QFontComboBox_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QFontComboBox_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QFontComboBox_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::setStyleSheet(QString(styleSheet));
}

void QFontComboBox_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QFontComboBox_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::setVisible(visible != 0);
}

void QFontComboBox_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QFontComboBox_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::setWindowModified(vbo != 0);
}

void QFontComboBox_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QFontComboBox_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::setWindowTitle(QString(vqs));
}

char QFontComboBox_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QFontComboBox_CloseDefault(void* ptr)
{
	return static_cast<QFontComboBox*>(ptr)->QFontComboBox::close();
}

void QFontComboBox_CloseEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QFontComboBox_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::closeEvent(static_cast<QCloseEvent*>(event));
}

char QFontComboBox_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QFontComboBox*>(ptr)->focusNextPrevChild(next != 0);
}

char QFontComboBox_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QFontComboBox*>(ptr)->QFontComboBox::focusNextPrevChild(next != 0);
}

char QFontComboBox_HasHeightForWidth(void* ptr)
{
	return static_cast<QFontComboBox*>(ptr)->hasHeightForWidth();
}

char QFontComboBox_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QFontComboBox*>(ptr)->QFontComboBox::hasHeightForWidth();
}

int QFontComboBox_HeightForWidth(void* ptr, int w)
{
	return static_cast<QFontComboBox*>(ptr)->heightForWidth(w);
}

int QFontComboBox_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QFontComboBox*>(ptr)->QFontComboBox::heightForWidth(w);
}

void QFontComboBox_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "hide");
}

void QFontComboBox_HideDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::hide();
}

void QFontComboBox_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "lower");
}

void QFontComboBox_LowerDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::lower();
}

void QFontComboBox_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QFontComboBox_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QFontComboBox_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QFontComboBox_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

char QFontComboBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QFontComboBox*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QFontComboBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QFontComboBox*>(ptr)->QFontComboBox::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QFontComboBox_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "raise");
}

void QFontComboBox_RaiseDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::raise();
}

void QFontComboBox_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "repaint");
}

void QFontComboBox_RepaintDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::repaint();
}

void QFontComboBox_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QFontComboBox_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::setDisabled(disable != 0);
}

void QFontComboBox_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setFocus");
}

void QFontComboBox_SetFocus2Default(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::setFocus();
}

void QFontComboBox_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QFontComboBox_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::setHidden(hidden != 0);
}

void QFontComboBox_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "show");
}

void QFontComboBox_ShowDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::show();
}

void QFontComboBox_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "showFullScreen");
}

void QFontComboBox_ShowFullScreenDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::showFullScreen();
}

void QFontComboBox_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "showMaximized");
}

void QFontComboBox_ShowMaximizedDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::showMaximized();
}

void QFontComboBox_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "showMinimized");
}

void QFontComboBox_ShowMinimizedDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::showMinimized();
}

void QFontComboBox_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "showNormal");
}

void QFontComboBox_ShowNormalDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::showNormal();
}

void QFontComboBox_TabletEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QFontComboBox_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QFontComboBox_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "update");
}

void QFontComboBox_UpdateDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::update();
}

void QFontComboBox_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "updateMicroFocus");
}

void QFontComboBox_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::updateMicroFocus();
}

void QFontComboBox_TimerEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QFontComboBox_ChildEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QFontComboBox_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QFontComboBox*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QFontComboBox_CustomEvent(void* ptr, void* event)
{
	static_cast<QFontComboBox*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QFontComboBox_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "deleteLater");
}

void QFontComboBox_DeleteLaterDefault(void* ptr)
{
	static_cast<QFontComboBox*>(ptr)->QFontComboBox::deleteLater();
}

void QFontComboBox_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QFontComboBox*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QFontComboBox_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QFontComboBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QFontComboBox_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QFontComboBox*>(ptr)->QFontComboBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QFontComboBox_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QFontComboBox*>(ptr)->metaObject());
}

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

class MyQFontDialog: public QFontDialog
{
public:
	MyQFontDialog(QWidget *parent) : QFontDialog(parent) {};
	MyQFontDialog(const QFont &initial, QWidget *parent) : QFontDialog(initial, parent) {};
	void changeEvent(QEvent * e) { callbackQFontDialog_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) { callbackQFontDialog_SetVisible(this, visible); };
	void accept() { callbackQFontDialog_Accept(this); };
	void closeEvent(QCloseEvent * e) { callbackQFontDialog_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQFontDialog_ContextMenuEvent(this, e); };
	int exec() { return callbackQFontDialog_Exec(this); };
	void keyPressEvent(QKeyEvent * e) { callbackQFontDialog_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQFontDialog_MinimumSizeHint(const_cast<MyQFontDialog*>(this))); };
	void reject() { callbackQFontDialog_Reject(this); };
	void resizeEvent(QResizeEvent * vqr) { callbackQFontDialog_ResizeEvent(this, vqr); };
	void showEvent(QShowEvent * event) { callbackQFontDialog_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQFontDialog_SizeHint(const_cast<MyQFontDialog*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQFontDialog_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQFontDialog_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQFontDialog_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQFontDialog_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQFontDialog_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQFontDialog_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQFontDialog_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQFontDialog_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQFontDialog_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQFontDialog_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQFontDialog_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQFontDialog_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQFontDialog_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQFontDialog_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setWindowModified(bool vbo) { callbackQFontDialog_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQFontDialog_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQFontDialog_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQFontDialog_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQFontDialog_HasHeightForWidth(const_cast<MyQFontDialog*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQFontDialog_HeightForWidth(const_cast<MyQFontDialog*>(this), w); };
	void hide() { callbackQFontDialog_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQFontDialog_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQFontDialog_InputMethodQuery(const_cast<MyQFontDialog*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQFontDialog_KeyReleaseEvent(this, event); };
	void lower() { callbackQFontDialog_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQFontDialog_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQFontDialog_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQFontDialog_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQFontDialog_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQFontDialog_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQFontDialog_Raise(this); };
	void repaint() { callbackQFontDialog_Repaint(this); };
	void setDisabled(bool disable) { callbackQFontDialog_SetDisabled(this, disable); };
	void setFocus() { callbackQFontDialog_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQFontDialog_SetHidden(this, hidden); };
	void show() { callbackQFontDialog_Show(this); };
	void showFullScreen() { callbackQFontDialog_ShowFullScreen(this); };
	void showMaximized() { callbackQFontDialog_ShowMaximized(this); };
	void showMinimized() { callbackQFontDialog_ShowMinimized(this); };
	void showNormal() { callbackQFontDialog_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQFontDialog_TabletEvent(this, event); };
	void update() { callbackQFontDialog_Update(this); };
	void updateMicroFocus() { callbackQFontDialog_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQFontDialog_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQFontDialog_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQFontDialog_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQFontDialog_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQFontDialog_CustomEvent(this, event); };
	void deleteLater() { callbackQFontDialog_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQFontDialog_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFontDialog_MetaObject(const_cast<MyQFontDialog*>(this))); };
};

long long QFontDialog_Options(void* ptr)
{
	return static_cast<QFontDialog*>(ptr)->options();
}

void QFontDialog_SetOptions(void* ptr, long long options)
{
	static_cast<QFontDialog*>(ptr)->setOptions(static_cast<QFontDialog::FontDialogOption>(options));
}

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_ChangeEvent(void* ptr, void* e)
{
	static_cast<QFontDialog*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QFontDialog_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::changeEvent(static_cast<QEvent*>(e));
}

void* QFontDialog_CurrentFont(void* ptr)
{
	return new QFont(static_cast<QFontDialog*>(ptr)->currentFont());
}

void QFontDialog_ConnectCurrentFontChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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_GetFont2(char ok, void* parent)
{
	return new QFont(QFontDialog::getFont(NULL, static_cast<QWidget*>(parent)));
}

void* QFontDialog_QFontDialog_GetFont(char ok, void* initial, void* parent, char* title, long long options)
{
	return new QFont(QFontDialog::getFont(NULL, *static_cast<QFont*>(initial), static_cast<QWidget*>(parent), QString(title), static_cast<QFontDialog::FontDialogOption>(options)));
}

void QFontDialog_Open(void* ptr, void* receiver, char* member)
{
	static_cast<QFontDialog*>(ptr)->open(static_cast<QObject*>(receiver), const_cast<const char*>(member));
}

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_SetVisible(void* ptr, char visible)
{
	static_cast<QFontDialog*>(ptr)->setVisible(visible != 0);
}

void QFontDialog_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::setVisible(visible != 0);
}

char QFontDialog_TestOption(void* ptr, long long option)
{
	return static_cast<QFontDialog*>(ptr)->testOption(static_cast<QFontDialog::FontDialogOption>(option));
}

void QFontDialog_Accept(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "accept");
}

void QFontDialog_AcceptDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::accept();
}

void QFontDialog_CloseEvent(void* ptr, void* e)
{
	static_cast<QFontDialog*>(ptr)->closeEvent(static_cast<QCloseEvent*>(e));
}

void QFontDialog_CloseEventDefault(void* ptr, void* e)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::closeEvent(static_cast<QCloseEvent*>(e));
}

void QFontDialog_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QFontDialog*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QFontDialog_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

int QFontDialog_Exec(void* ptr)
{
	int returnArg;
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "exec", Q_RETURN_ARG(int, returnArg));
	return returnArg;
}

int QFontDialog_ExecDefault(void* ptr)
{
	return static_cast<QFontDialog*>(ptr)->QFontDialog::exec();
}

void QFontDialog_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QFontDialog*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QFontDialog_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void* QFontDialog_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFontDialog*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QFontDialog_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFontDialog*>(ptr)->QFontDialog::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QFontDialog_Reject(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "reject");
}

void QFontDialog_RejectDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::reject();
}

void QFontDialog_ResizeEvent(void* ptr, void* vqr)
{
	static_cast<QFontDialog*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QFontDialog_ResizeEventDefault(void* ptr, void* vqr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QFontDialog_ShowEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QFontDialog_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::showEvent(static_cast<QShowEvent*>(event));
}

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

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

void QFontDialog_ActionEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QFontDialog_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::actionEvent(static_cast<QActionEvent*>(event));
}

void QFontDialog_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QFontDialog_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QFontDialog_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QFontDialog_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QFontDialog_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QFontDialog_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QFontDialog_DropEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QFontDialog_DropEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::dropEvent(static_cast<QDropEvent*>(event));
}

void QFontDialog_EnterEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QFontDialog_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::enterEvent(static_cast<QEvent*>(event));
}

void QFontDialog_FocusInEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QFontDialog_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QFontDialog_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QFontDialog_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QFontDialog_HideEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QFontDialog_HideEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::hideEvent(static_cast<QHideEvent*>(event));
}

void QFontDialog_LeaveEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QFontDialog_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::leaveEvent(static_cast<QEvent*>(event));
}

void QFontDialog_MoveEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QFontDialog_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::moveEvent(static_cast<QMoveEvent*>(event));
}

void QFontDialog_PaintEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QFontDialog_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::paintEvent(static_cast<QPaintEvent*>(event));
}

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

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

void QFontDialog_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QFontDialog_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::setStyleSheet(QString(styleSheet));
}

void QFontDialog_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QFontDialog_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::setWindowModified(vbo != 0);
}

void QFontDialog_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QFontDialog_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::setWindowTitle(QString(vqs));
}

char QFontDialog_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QFontDialog_CloseDefault(void* ptr)
{
	return static_cast<QFontDialog*>(ptr)->QFontDialog::close();
}

char QFontDialog_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QFontDialog*>(ptr)->focusNextPrevChild(next != 0);
}

char QFontDialog_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QFontDialog*>(ptr)->QFontDialog::focusNextPrevChild(next != 0);
}

char QFontDialog_HasHeightForWidth(void* ptr)
{
	return static_cast<QFontDialog*>(ptr)->hasHeightForWidth();
}

char QFontDialog_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QFontDialog*>(ptr)->QFontDialog::hasHeightForWidth();
}

int QFontDialog_HeightForWidth(void* ptr, int w)
{
	return static_cast<QFontDialog*>(ptr)->heightForWidth(w);
}

int QFontDialog_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QFontDialog*>(ptr)->QFontDialog::heightForWidth(w);
}

void QFontDialog_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "hide");
}

void QFontDialog_HideDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::hide();
}

void QFontDialog_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QFontDialog_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QFontDialog_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QFontDialog*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QFontDialog_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QFontDialog*>(ptr)->QFontDialog::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QFontDialog_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QFontDialog_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QFontDialog_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "lower");
}

void QFontDialog_LowerDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::lower();
}

void QFontDialog_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QFontDialog_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QFontDialog_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QFontDialog_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QFontDialog_MousePressEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QFontDialog_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QFontDialog_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QFontDialog_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QFontDialog_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QFontDialog*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QFontDialog_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QFontDialog*>(ptr)->QFontDialog::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QFontDialog_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "raise");
}

void QFontDialog_RaiseDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::raise();
}

void QFontDialog_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "repaint");
}

void QFontDialog_RepaintDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::repaint();
}

void QFontDialog_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QFontDialog_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::setDisabled(disable != 0);
}

void QFontDialog_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "setFocus");
}

void QFontDialog_SetFocus2Default(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::setFocus();
}

void QFontDialog_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QFontDialog_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::setHidden(hidden != 0);
}

void QFontDialog_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "show");
}

void QFontDialog_ShowDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::show();
}

void QFontDialog_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "showFullScreen");
}

void QFontDialog_ShowFullScreenDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::showFullScreen();
}

void QFontDialog_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "showMaximized");
}

void QFontDialog_ShowMaximizedDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::showMaximized();
}

void QFontDialog_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "showMinimized");
}

void QFontDialog_ShowMinimizedDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::showMinimized();
}

void QFontDialog_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "showNormal");
}

void QFontDialog_ShowNormalDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::showNormal();
}

void QFontDialog_TabletEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QFontDialog_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QFontDialog_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "update");
}

void QFontDialog_UpdateDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::update();
}

void QFontDialog_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "updateMicroFocus");
}

void QFontDialog_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::updateMicroFocus();
}

void QFontDialog_WheelEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QFontDialog_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QFontDialog_TimerEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QFontDialog_ChildEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QFontDialog_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QFontDialog*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QFontDialog_CustomEvent(void* ptr, void* event)
{
	static_cast<QFontDialog*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QFontDialog_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "deleteLater");
}

void QFontDialog_DeleteLaterDefault(void* ptr)
{
	static_cast<QFontDialog*>(ptr)->QFontDialog::deleteLater();
}

void QFontDialog_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QFontDialog*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void* QFontDialog_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QFontDialog*>(ptr)->metaObject());
}

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

class MyQFormLayout: public QFormLayout
{
public:
	MyQFormLayout(QWidget *parent) : QFormLayout(parent) {};
	void addItem(QLayoutItem * item) { callbackQFormLayout_AddItem(this, item); };
	int count() const { return callbackQFormLayout_Count(const_cast<MyQFormLayout*>(this)); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQFormLayout_ExpandingDirections(const_cast<MyQFormLayout*>(this))); };
	bool hasHeightForWidth() const { return callbackQFormLayout_HasHeightForWidth(const_cast<MyQFormLayout*>(this)) != 0; };
	int heightForWidth(int width) const { return callbackQFormLayout_HeightForWidth(const_cast<MyQFormLayout*>(this), width); };
	void invalidate() { callbackQFormLayout_Invalidate(this); };
	QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQFormLayout_ItemAt2(const_cast<MyQFormLayout*>(this), index)); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQFormLayout_MinimumSize(const_cast<MyQFormLayout*>(this))); };
	void setGeometry(const QRect & rect) { callbackQFormLayout_SetGeometry(this, const_cast<QRect*>(&rect)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQFormLayout_SizeHint(const_cast<MyQFormLayout*>(this))); };
	QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQFormLayout_TakeAt(this, index)); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQFormLayout_ControlTypes(const_cast<MyQFormLayout*>(this))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQFormLayout_Geometry(const_cast<MyQFormLayout*>(this))); };
	int indexOf(QWidget * widget) const { return callbackQFormLayout_IndexOf(const_cast<MyQFormLayout*>(this), widget); };
	bool isEmpty() const { return callbackQFormLayout_IsEmpty(const_cast<MyQFormLayout*>(this)) != 0; };
	QLayout * layout() { return static_cast<QLayout*>(callbackQFormLayout_Layout(this)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQFormLayout_MaximumSize(const_cast<MyQFormLayout*>(this))); };
	void timerEvent(QTimerEvent * event) { callbackQFormLayout_TimerEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQFormLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQFormLayout_CustomEvent(this, event); };
	void deleteLater() { callbackQFormLayout_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQFormLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQFormLayout_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQFormLayout_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFormLayout_MetaObject(const_cast<MyQFormLayout*>(this))); };
	int minimumHeightForWidth(int w) const { return callbackQFormLayout_MinimumHeightForWidth(const_cast<MyQFormLayout*>(this), w); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQFormLayout_SpacerItem(this)); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQFormLayout_Widget(this)); };
};

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();
}

long long QFormLayout_LabelAlignment(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->labelAlignment();
}

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_SetLabelAlignment(void* ptr, long long alignment)
{
	static_cast<QFormLayout*>(ptr)->setLabelAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}

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);
}

int QFormLayout_VerticalSpacing(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->verticalSpacing();
}

void* QFormLayout_NewQFormLayout(void* parent)
{
	return new MyQFormLayout(static_cast<QWidget*>(parent));
}

void QFormLayout_AddItem(void* ptr, void* item)
{
	static_cast<QFormLayout*>(ptr)->addItem(static_cast<QLayoutItem*>(item));
}

void QFormLayout_AddItemDefault(void* ptr, void* item)
{
	static_cast<QFormLayout*>(ptr)->QFormLayout::addItem(static_cast<QLayoutItem*>(item));
}

void QFormLayout_AddRow6(void* ptr, void* layout)
{
	static_cast<QFormLayout*>(ptr)->addRow(static_cast<QLayout*>(layout));
}

void QFormLayout_AddRow2(void* ptr, void* label, void* field)
{
	static_cast<QFormLayout*>(ptr)->addRow(static_cast<QWidget*>(label), static_cast<QLayout*>(field));
}

void QFormLayout_AddRow(void* ptr, void* label, void* field)
{
	static_cast<QFormLayout*>(ptr)->addRow(static_cast<QWidget*>(label), static_cast<QWidget*>(field));
}

void QFormLayout_AddRow5(void* ptr, void* widget)
{
	static_cast<QFormLayout*>(ptr)->addRow(static_cast<QWidget*>(widget));
}

void QFormLayout_AddRow4(void* ptr, char* labelText, void* field)
{
	static_cast<QFormLayout*>(ptr)->addRow(QString(labelText), static_cast<QLayout*>(field));
}

void QFormLayout_AddRow3(void* ptr, char* labelText, void* field)
{
	static_cast<QFormLayout*>(ptr)->addRow(QString(labelText), static_cast<QWidget*>(field));
}

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_ExpandingDirections(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->expandingDirections();
}

long long QFormLayout_ExpandingDirectionsDefault(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->QFormLayout::expandingDirections();
}

char QFormLayout_HasHeightForWidth(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->hasHeightForWidth();
}

char QFormLayout_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->QFormLayout::hasHeightForWidth();
}

int QFormLayout_HeightForWidth(void* ptr, int width)
{
	return static_cast<QFormLayout*>(ptr)->heightForWidth(width);
}

int QFormLayout_HeightForWidthDefault(void* ptr, int width)
{
	return static_cast<QFormLayout*>(ptr)->QFormLayout::heightForWidth(width);
}

void QFormLayout_InsertRow6(void* ptr, int row, void* layout)
{
	static_cast<QFormLayout*>(ptr)->insertRow(row, static_cast<QLayout*>(layout));
}

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_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_InsertRow5(void* ptr, int row, void* widget)
{
	static_cast<QFormLayout*>(ptr)->insertRow(row, static_cast<QWidget*>(widget));
}

void QFormLayout_InsertRow4(void* ptr, int row, char* labelText, void* field)
{
	static_cast<QFormLayout*>(ptr)->insertRow(row, QString(labelText), static_cast<QLayout*>(field));
}

void QFormLayout_InsertRow3(void* ptr, int row, char* labelText, void* field)
{
	static_cast<QFormLayout*>(ptr)->insertRow(row, QString(labelText), static_cast<QWidget*>(field));
}

void QFormLayout_Invalidate(void* ptr)
{
	static_cast<QFormLayout*>(ptr)->invalidate();
}

void QFormLayout_InvalidateDefault(void* ptr)
{
	static_cast<QFormLayout*>(ptr)->QFormLayout::invalidate();
}

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

void* QFormLayout_ItemAt2Default(void* ptr, int index)
{
	return static_cast<QFormLayout*>(ptr)->QFormLayout::itemAt(index);
}

void* QFormLayout_ItemAt(void* ptr, int row, long long role)
{
	return static_cast<QFormLayout*>(ptr)->itemAt(row, static_cast<QFormLayout::ItemRole>(role));
}

void* QFormLayout_LabelForField2(void* ptr, void* field)
{
	return static_cast<QFormLayout*>(ptr)->labelForField(static_cast<QLayout*>(field));
}

void* QFormLayout_LabelForField(void* ptr, void* field)
{
	return static_cast<QFormLayout*>(ptr)->labelForField(static_cast<QWidget*>(field));
}

void* QFormLayout_MinimumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFormLayout*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QFormLayout_MinimumSizeDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFormLayout*>(ptr)->QFormLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QFormLayout_RowCount(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->rowCount();
}

void QFormLayout_SetGeometry(void* ptr, void* rect)
{
	static_cast<QFormLayout*>(ptr)->setGeometry(*static_cast<QRect*>(rect));
}

void QFormLayout_SetGeometryDefault(void* ptr, void* rect)
{
	static_cast<QFormLayout*>(ptr)->QFormLayout::setGeometry(*static_cast<QRect*>(rect));
}

void QFormLayout_SetItem(void* ptr, int row, long long role, void* item)
{
	static_cast<QFormLayout*>(ptr)->setItem(row, static_cast<QFormLayout::ItemRole>(role), static_cast<QLayoutItem*>(item));
}

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_SetSpacing(void* ptr, int spacing)
{
	static_cast<QFormLayout*>(ptr)->setSpacing(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()); });
}

int QFormLayout_Spacing(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->spacing();
}

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);
}

void QFormLayout_DestroyQFormLayout(void* ptr)
{
	static_cast<QFormLayout*>(ptr)->~QFormLayout();
}

long long QFormLayout_ControlTypes(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->controlTypes();
}

long long QFormLayout_ControlTypesDefault(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->QFormLayout::controlTypes();
}

void* QFormLayout_Geometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QFormLayout*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

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

int QFormLayout_IndexOf(void* ptr, void* widget)
{
	return static_cast<QFormLayout*>(ptr)->indexOf(static_cast<QWidget*>(widget));
}

int QFormLayout_IndexOfDefault(void* ptr, void* widget)
{
	return static_cast<QFormLayout*>(ptr)->QFormLayout::indexOf(static_cast<QWidget*>(widget));
}

char QFormLayout_IsEmpty(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->isEmpty();
}

char QFormLayout_IsEmptyDefault(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->QFormLayout::isEmpty();
}

void* QFormLayout_Layout(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->layout();
}

void* QFormLayout_LayoutDefault(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->QFormLayout::layout();
}

void* QFormLayout_MaximumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFormLayout*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QFormLayout_MaximumSizeDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFormLayout*>(ptr)->QFormLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QFormLayout_TimerEvent(void* ptr, void* event)
{
	static_cast<QFormLayout*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QFormLayout_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QFormLayout*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QFormLayout_CustomEvent(void* ptr, void* event)
{
	static_cast<QFormLayout*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QFormLayout_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFormLayout*>(ptr), "deleteLater");
}

void QFormLayout_DeleteLaterDefault(void* ptr)
{
	static_cast<QFormLayout*>(ptr)->QFormLayout::deleteLater();
}

void QFormLayout_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QFormLayout*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QFormLayout_Event(void* ptr, void* e)
{
	return static_cast<QFormLayout*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QFormLayout_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QFormLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QFormLayout_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QFormLayout*>(ptr)->QFormLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QFormLayout_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QFormLayout*>(ptr)->metaObject());
}

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

int QFormLayout_MinimumHeightForWidth(void* ptr, int w)
{
	return static_cast<QFormLayout*>(ptr)->minimumHeightForWidth(w);
}

int QFormLayout_MinimumHeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QFormLayout*>(ptr)->QFormLayout::minimumHeightForWidth(w);
}

void* QFormLayout_SpacerItem(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->spacerItem();
}

void* QFormLayout_SpacerItemDefault(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->QFormLayout::spacerItem();
}

void* QFormLayout_Widget(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->widget();
}

void* QFormLayout_WidgetDefault(void* ptr)
{
	return static_cast<QFormLayout*>(ptr)->QFormLayout::widget();
}

class MyQFrame: public QFrame
{
public:
	MyQFrame(QWidget *parent, Qt::WindowFlags f) : QFrame(parent, f) {};
	void changeEvent(QEvent * ev) { callbackQFrame_ChangeEvent(this, ev); };
	void paintEvent(QPaintEvent * vqp) { callbackQFrame_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQFrame_SizeHint(const_cast<MyQFrame*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQFrame_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQFrame_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQFrame_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQFrame_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQFrame_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQFrame_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQFrame_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQFrame_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQFrame_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQFrame_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQFrame_MinimumSizeHint(const_cast<MyQFrame*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQFrame_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQFrame_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQFrame_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQFrame_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQFrame_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQFrame_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQFrame_ShowEvent(this, event); };
	bool close() { return callbackQFrame_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQFrame_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQFrame_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQFrame_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQFrame_HasHeightForWidth(const_cast<MyQFrame*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQFrame_HeightForWidth(const_cast<MyQFrame*>(this), w); };
	void hide() { callbackQFrame_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQFrame_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQFrame_InputMethodQuery(const_cast<MyQFrame*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQFrame_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQFrame_KeyReleaseEvent(this, event); };
	void lower() { callbackQFrame_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQFrame_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQFrame_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQFrame_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQFrame_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQFrame_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQFrame_Raise(this); };
	void repaint() { callbackQFrame_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQFrame_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQFrame_SetDisabled(this, disable); };
	void setFocus() { callbackQFrame_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQFrame_SetHidden(this, hidden); };
	void show() { callbackQFrame_Show(this); };
	void showFullScreen() { callbackQFrame_ShowFullScreen(this); };
	void showMaximized() { callbackQFrame_ShowMaximized(this); };
	void showMinimized() { callbackQFrame_ShowMinimized(this); };
	void showNormal() { callbackQFrame_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQFrame_TabletEvent(this, event); };
	void update() { callbackQFrame_Update(this); };
	void updateMicroFocus() { callbackQFrame_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQFrame_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQFrame_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQFrame_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQFrame_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQFrame_CustomEvent(this, event); };
	void deleteLater() { callbackQFrame_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQFrame_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQFrame_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFrame_MetaObject(const_cast<MyQFrame*>(this))); };
};

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_FrameWidth(void* ptr)
{
	return static_cast<QFrame*>(ptr)->frameWidth();
}

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 vsh)
{
	static_cast<QFrame*>(ptr)->setFrameShadow(static_cast<QFrame::Shadow>(vsh));
}

void QFrame_SetFrameShape(void* ptr, long long vsh)
{
	static_cast<QFrame*>(ptr)->setFrameShape(static_cast<QFrame::Shape>(vsh));
}

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_NewQFrame(void* parent, long long f)
{
	return new MyQFrame(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
}

void QFrame_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QFrame*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QFrame_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QFrame*>(ptr)->QFrame::changeEvent(static_cast<QEvent*>(ev));
}

char QFrame_Event(void* ptr, void* e)
{
	return static_cast<QFrame*>(ptr)->event(static_cast<QEvent*>(e));
}

int QFrame_FrameStyle(void* ptr)
{
	return static_cast<QFrame*>(ptr)->frameStyle();
}

void QFrame_InitStyleOption(void* ptr, void* option)
{
	static_cast<QFrame*>(ptr)->initStyleOption(static_cast<QStyleOptionFrame*>(option));
}

void QFrame_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QFrame*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QFrame_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QFrame*>(ptr)->QFrame::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QFrame_SetFrameStyle(void* ptr, int style)
{
	static_cast<QFrame*>(ptr)->setFrameStyle(style);
}

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

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

void QFrame_DestroyQFrame(void* ptr)
{
	static_cast<QFrame*>(ptr)->~QFrame();
}

void QFrame_ActionEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QFrame_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::actionEvent(static_cast<QActionEvent*>(event));
}

void QFrame_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QFrame_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QFrame_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QFrame_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QFrame_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QFrame_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QFrame_DropEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QFrame_DropEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::dropEvent(static_cast<QDropEvent*>(event));
}

void QFrame_EnterEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QFrame_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::enterEvent(static_cast<QEvent*>(event));
}

void QFrame_FocusInEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QFrame_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QFrame_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QFrame_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QFrame_HideEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QFrame_HideEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::hideEvent(static_cast<QHideEvent*>(event));
}

void QFrame_LeaveEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QFrame_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::leaveEvent(static_cast<QEvent*>(event));
}

void* QFrame_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFrame*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QFrame_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QFrame*>(ptr)->QFrame::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QFrame_MoveEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QFrame_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QFrame_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QFrame_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QFrame*>(ptr)->QFrame::setStyleSheet(QString(styleSheet));
}

void QFrame_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QFrame_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QFrame*>(ptr)->QFrame::setVisible(visible != 0);
}

void QFrame_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QFrame_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QFrame*>(ptr)->QFrame::setWindowModified(vbo != 0);
}

void QFrame_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QFrame_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QFrame*>(ptr)->QFrame::setWindowTitle(QString(vqs));
}

void QFrame_ShowEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QFrame_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::showEvent(static_cast<QShowEvent*>(event));
}

char QFrame_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QFrame_CloseDefault(void* ptr)
{
	return static_cast<QFrame*>(ptr)->QFrame::close();
}

void QFrame_CloseEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QFrame_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::closeEvent(static_cast<QCloseEvent*>(event));
}

void QFrame_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QFrame_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QFrame_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QFrame*>(ptr)->focusNextPrevChild(next != 0);
}

char QFrame_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QFrame*>(ptr)->QFrame::focusNextPrevChild(next != 0);
}

char QFrame_HasHeightForWidth(void* ptr)
{
	return static_cast<QFrame*>(ptr)->hasHeightForWidth();
}

char QFrame_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QFrame*>(ptr)->QFrame::hasHeightForWidth();
}

int QFrame_HeightForWidth(void* ptr, int w)
{
	return static_cast<QFrame*>(ptr)->heightForWidth(w);
}

int QFrame_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QFrame*>(ptr)->QFrame::heightForWidth(w);
}

void QFrame_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "hide");
}

void QFrame_HideDefault(void* ptr)
{
	static_cast<QFrame*>(ptr)->QFrame::hide();
}

void QFrame_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QFrame_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QFrame_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QFrame*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QFrame_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QFrame*>(ptr)->QFrame::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QFrame_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QFrame_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QFrame_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QFrame_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QFrame_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "lower");
}

void QFrame_LowerDefault(void* ptr)
{
	static_cast<QFrame*>(ptr)->QFrame::lower();
}

void QFrame_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QFrame_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QFrame_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QFrame_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QFrame_MousePressEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QFrame_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QFrame_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QFrame_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QFrame_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QFrame*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QFrame_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QFrame*>(ptr)->QFrame::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QFrame_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "raise");
}

void QFrame_RaiseDefault(void* ptr)
{
	static_cast<QFrame*>(ptr)->QFrame::raise();
}

void QFrame_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "repaint");
}

void QFrame_RepaintDefault(void* ptr)
{
	static_cast<QFrame*>(ptr)->QFrame::repaint();
}

void QFrame_ResizeEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QFrame_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QFrame_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QFrame_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QFrame*>(ptr)->QFrame::setDisabled(disable != 0);
}

void QFrame_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "setFocus");
}

void QFrame_SetFocus2Default(void* ptr)
{
	static_cast<QFrame*>(ptr)->QFrame::setFocus();
}

void QFrame_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QFrame_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QFrame*>(ptr)->QFrame::setHidden(hidden != 0);
}

void QFrame_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "show");
}

void QFrame_ShowDefault(void* ptr)
{
	static_cast<QFrame*>(ptr)->QFrame::show();
}

void QFrame_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "showFullScreen");
}

void QFrame_ShowFullScreenDefault(void* ptr)
{
	static_cast<QFrame*>(ptr)->QFrame::showFullScreen();
}

void QFrame_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "showMaximized");
}

void QFrame_ShowMaximizedDefault(void* ptr)
{
	static_cast<QFrame*>(ptr)->QFrame::showMaximized();
}

void QFrame_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "showMinimized");
}

void QFrame_ShowMinimizedDefault(void* ptr)
{
	static_cast<QFrame*>(ptr)->QFrame::showMinimized();
}

void QFrame_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "showNormal");
}

void QFrame_ShowNormalDefault(void* ptr)
{
	static_cast<QFrame*>(ptr)->QFrame::showNormal();
}

void QFrame_TabletEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QFrame_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QFrame_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "update");
}

void QFrame_UpdateDefault(void* ptr)
{
	static_cast<QFrame*>(ptr)->QFrame::update();
}

void QFrame_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "updateMicroFocus");
}

void QFrame_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QFrame*>(ptr)->QFrame::updateMicroFocus();
}

void QFrame_WheelEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QFrame_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->QFrame::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QFrame_TimerEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QFrame_ChildEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QFrame_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QFrame*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QFrame_CustomEvent(void* ptr, void* event)
{
	static_cast<QFrame*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QFrame_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "deleteLater");
}

void QFrame_DeleteLaterDefault(void* ptr)
{
	static_cast<QFrame*>(ptr)->QFrame::deleteLater();
}

void QFrame_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QFrame*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QFrame_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QFrame*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QFrame_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QFrame*>(ptr)->QFrame::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QFrame_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QFrame*>(ptr)->metaObject());
}

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

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_NewQGesture(void* parent)
{
	return new QGesture(static_cast<QObject*>(parent));
}

void QGesture_DestroyQGesture(void* ptr)
{
	static_cast<QGesture*>(ptr)->~QGesture();
}

void QGesture_TimerEvent(void* ptr, void* event)
{
	static_cast<QGesture*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGesture_ChildEvent(void* ptr, void* event)
{
	static_cast<QGesture*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGesture_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGesture*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGesture_CustomEvent(void* ptr, void* event)
{
	static_cast<QGesture*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGesture_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGesture*>(ptr), "deleteLater");
}

void QGesture_DeleteLaterDefault(void* ptr)
{
	static_cast<QGesture*>(ptr)->QGesture::deleteLater();
}

void QGesture_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGesture*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGesture_Event(void* ptr, void* e)
{
	return static_cast<QGesture*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QGesture_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGesture*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGesture_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGesture*>(ptr)->QGesture::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGesture_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGesture*>(ptr)->metaObject());
}

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

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));
}

void* QGestureEvent_Gesture(void* ptr, long long ty)
{
	return static_cast<QGestureEvent*>(ptr)->gesture(static_cast<Qt::GestureType>(ty));
}

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();
}

class MyQGestureRecognizer: public QGestureRecognizer
{
public:
	MyQGestureRecognizer() : QGestureRecognizer() {};
	QGesture * create(QObject * target) { return static_cast<QGesture*>(callbackQGestureRecognizer_Create(this, target)); };
	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); };
};

void* QGestureRecognizer_NewQGestureRecognizer()
{
	return new MyQGestureRecognizer();
}

void* QGestureRecognizer_Create(void* ptr, void* target)
{
	return static_cast<QGestureRecognizer*>(ptr)->create(static_cast<QObject*>(target));
}

void* QGestureRecognizer_CreateDefault(void* ptr, void* target)
{
	return static_cast<QGestureRecognizer*>(ptr)->QGestureRecognizer::create(static_cast<QObject*>(target));
}

long long QGestureRecognizer_Recognize(void* ptr, void* gesture, void* watched, void* event)
{
	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)
{

}

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_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsAnchor*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsAnchor_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsAnchor*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsAnchor_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsAnchor*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsAnchor_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsAnchor*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsAnchor_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsAnchor*>(ptr), "deleteLater");
}

void QGraphicsAnchor_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsAnchor*>(ptr)->QGraphicsAnchor::deleteLater();
}

void QGraphicsAnchor_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsAnchor*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGraphicsAnchor_Event(void* ptr, void* e)
{
	return static_cast<QGraphicsAnchor*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QGraphicsAnchor_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsAnchor*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsAnchor_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsAnchor*>(ptr)->QGraphicsAnchor::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsAnchor_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsAnchor*>(ptr)->metaObject());
}

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

class MyQGraphicsAnchorLayout: public QGraphicsAnchorLayout
{
public:
	MyQGraphicsAnchorLayout(QGraphicsLayoutItem *parent) : QGraphicsAnchorLayout(parent) {};
	int count() const { return callbackQGraphicsAnchorLayout_Count(const_cast<MyQGraphicsAnchorLayout*>(this)); };
	void invalidate() { callbackQGraphicsAnchorLayout_Invalidate(this); };
	QGraphicsLayoutItem * itemAt(int index) const { return static_cast<QGraphicsLayoutItem*>(callbackQGraphicsAnchorLayout_ItemAt(const_cast<MyQGraphicsAnchorLayout*>(this), index)); };
	void removeAt(int index) { callbackQGraphicsAnchorLayout_RemoveAt(this, index); };
	void setGeometry(const QRectF & geom) { callbackQGraphicsAnchorLayout_SetGeometry(this, const_cast<QRectF*>(&geom)); };
	QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsAnchorLayout_SizeHint(const_cast<MyQGraphicsAnchorLayout*>(this), which, const_cast<QSizeF*>(&constraint))); };
	 ~MyQGraphicsAnchorLayout() { callbackQGraphicsAnchorLayout_DestroyQGraphicsAnchorLayout(this); };
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsAnchorLayout_GetContentsMargins(const_cast<MyQGraphicsAnchorLayout*>(this), *left, *top, *right, *bottom); };
	void updateGeometry() { callbackQGraphicsAnchorLayout_UpdateGeometry(this); };
	void widgetEvent(QEvent * e) { callbackQGraphicsAnchorLayout_WidgetEvent(this, e); };
};

void* QGraphicsAnchorLayout_NewQGraphicsAnchorLayout(void* parent)
{
	return new MyQGraphicsAnchorLayout(static_cast<QGraphicsLayoutItem*>(parent));
}

void* QGraphicsAnchorLayout_AddAnchor(void* ptr, void* firstItem, long long firstEdge, void* secondItem, long long secondEdge)
{
	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)
{
	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)
{
	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)
{
	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_Invalidate(void* ptr)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->invalidate();
}

void QGraphicsAnchorLayout_InvalidateDefault(void* ptr)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::invalidate();
}

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_SetGeometry(void* ptr, void* geom)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->setGeometry(*static_cast<QRectF*>(geom));
}

void QGraphicsAnchorLayout_SetGeometryDefault(void* ptr, void* geom)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::setGeometry(*static_cast<QRectF*>(geom));
}

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)
{

}

void QGraphicsAnchorLayout_GetContentsMargins(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->getContentsMargins(&left, &top, &right, &bottom);
}

void QGraphicsAnchorLayout_GetContentsMarginsDefault(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::getContentsMargins(&left, &top, &right, &bottom);
}

void QGraphicsAnchorLayout_UpdateGeometry(void* ptr)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->updateGeometry();
}

void QGraphicsAnchorLayout_UpdateGeometryDefault(void* ptr)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::updateGeometry();
}

void QGraphicsAnchorLayout_WidgetEvent(void* ptr, void* e)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->widgetEvent(static_cast<QEvent*>(e));
}

void QGraphicsAnchorLayout_WidgetEventDefault(void* ptr, void* e)
{
	static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::widgetEvent(static_cast<QEvent*>(e));
}

class MyQGraphicsBlurEffect: public QGraphicsBlurEffect
{
public:
	MyQGraphicsBlurEffect(QObject *parent) : QGraphicsBlurEffect(parent) {};
	void setBlurHints(QGraphicsBlurEffect::BlurHints hints) { callbackQGraphicsBlurEffect_SetBlurHints(this, hints); };
	void setBlurRadius(qreal blurRadius) { callbackQGraphicsBlurEffect_SetBlurRadius(this, blurRadius); };
	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*>(callbackQGraphicsBlurEffect_BoundingRectFor(const_cast<MyQGraphicsBlurEffect*>(this), const_cast<QRectF*>(&rect))); };
	void draw(QPainter * painter) { callbackQGraphicsBlurEffect_Draw(this, painter); };
	void setEnabled(bool enable) { callbackQGraphicsBlurEffect_SetEnabled(this, enable); };
	void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsBlurEffect_SourceChanged(this, flags); };
	void update() { callbackQGraphicsBlurEffect_Update(this); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsBlurEffect_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQGraphicsBlurEffect_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsBlurEffect_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsBlurEffect_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsBlurEffect_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsBlurEffect_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsBlurEffect_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsBlurEffect_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsBlurEffect_MetaObject(const_cast<MyQGraphicsBlurEffect*>(this))); };
};

long long QGraphicsBlurEffect_BlurHints(void* ptr)
{
	return static_cast<QGraphicsBlurEffect*>(ptr)->blurHints();
}

double QGraphicsBlurEffect_BlurRadius(void* ptr)
{
	return static_cast<QGraphicsBlurEffect*>(ptr)->blurRadius();
}

void QGraphicsBlurEffect_SetBlurHints(void* ptr, long long hints)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsBlurEffect*>(ptr), "setBlurHints", Q_ARG(QGraphicsBlurEffect::BlurHint, 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_NewQGraphicsBlurEffect(void* parent)
{
	return new MyQGraphicsBlurEffect(static_cast<QObject*>(parent));
}

void QGraphicsBlurEffect_ConnectBlurHintsChanged(void* ptr)
{
	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));
}

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));
}

void QGraphicsBlurEffect_ConnectBlurRadiusChanged(void* ptr)
{
	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));
}

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_BoundingRectFor(void* ptr, void* rect)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsBlurEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsBlurEffect_BoundingRectForDefault(void* ptr, void* rect)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

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_DestroyQGraphicsBlurEffect(void* ptr)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->~QGraphicsBlurEffect();
}

void QGraphicsBlurEffect_SetEnabled(void* ptr, char enable)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsBlurEffect*>(ptr), "setEnabled", Q_ARG(bool, enable != 0));
}

void QGraphicsBlurEffect_SetEnabledDefault(void* ptr, char enable)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::setEnabled(enable != 0);
}

void QGraphicsBlurEffect_SourceChanged(void* ptr, long long flags)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}

void QGraphicsBlurEffect_SourceChangedDefault(void* ptr, long long flags)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}

void QGraphicsBlurEffect_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsBlurEffect*>(ptr), "update");
}

void QGraphicsBlurEffect_UpdateDefault(void* ptr)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::update();
}

void QGraphicsBlurEffect_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsBlurEffect_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsBlurEffect_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsBlurEffect_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsBlurEffect_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsBlurEffect*>(ptr), "deleteLater");
}

void QGraphicsBlurEffect_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::deleteLater();
}

void QGraphicsBlurEffect_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsBlurEffect*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGraphicsBlurEffect_Event(void* ptr, void* e)
{
	return static_cast<QGraphicsBlurEffect*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QGraphicsBlurEffect_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsBlurEffect*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsBlurEffect_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsBlurEffect_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsBlurEffect*>(ptr)->metaObject());
}

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

class MyQGraphicsColorizeEffect: public QGraphicsColorizeEffect
{
public:
	MyQGraphicsColorizeEffect(QObject *parent) : QGraphicsColorizeEffect(parent) {};
	void setColor(const QColor & c) { callbackQGraphicsColorizeEffect_SetColor(this, const_cast<QColor*>(&c)); };
	void setStrength(qreal strength) { callbackQGraphicsColorizeEffect_SetStrength(this, strength); };
	void Signal_ColorChanged(const QColor & color) { callbackQGraphicsColorizeEffect_ColorChanged(this, const_cast<QColor*>(&color)); };
	void draw(QPainter * painter) { callbackQGraphicsColorizeEffect_Draw(this, painter); };
	void Signal_StrengthChanged(qreal strength) { callbackQGraphicsColorizeEffect_StrengthChanged(this, strength); };
	void setEnabled(bool enable) { callbackQGraphicsColorizeEffect_SetEnabled(this, enable); };
	QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsColorizeEffect_BoundingRectFor(const_cast<MyQGraphicsColorizeEffect*>(this), const_cast<QRectF*>(&rect))); };
	void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsColorizeEffect_SourceChanged(this, flags); };
	void update() { callbackQGraphicsColorizeEffect_Update(this); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsColorizeEffect_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQGraphicsColorizeEffect_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsColorizeEffect_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsColorizeEffect_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsColorizeEffect_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsColorizeEffect_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsColorizeEffect_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsColorizeEffect_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsColorizeEffect_MetaObject(const_cast<MyQGraphicsColorizeEffect*>(this))); };
};

void* QGraphicsColorizeEffect_Color(void* ptr)
{
	return new QColor(static_cast<QGraphicsColorizeEffect*>(ptr)->color());
}

void QGraphicsColorizeEffect_SetColor(void* ptr, void* c)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsColorizeEffect*>(ptr), "setColor", Q_ARG(QColor, *static_cast<QColor*>(c)));
}

void QGraphicsColorizeEffect_SetStrength(void* ptr, double strength)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsColorizeEffect*>(ptr), "setStrength", Q_ARG(qreal, strength));
}

double QGraphicsColorizeEffect_Strength(void* ptr)
{
	return static_cast<QGraphicsColorizeEffect*>(ptr)->strength();
}

void* QGraphicsColorizeEffect_NewQGraphicsColorizeEffect(void* parent)
{
	return new MyQGraphicsColorizeEffect(static_cast<QObject*>(parent));
}

void QGraphicsColorizeEffect_ConnectColorChanged(void* ptr)
{
	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));
}

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_ConnectStrengthChanged(void* ptr)
{
	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));
}

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_SetEnabled(void* ptr, char enable)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsColorizeEffect*>(ptr), "setEnabled", Q_ARG(bool, enable != 0));
}

void QGraphicsColorizeEffect_SetEnabledDefault(void* ptr, char enable)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::setEnabled(enable != 0);
}

void* QGraphicsColorizeEffect_BoundingRectFor(void* ptr, void* rect)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsColorizeEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsColorizeEffect_BoundingRectForDefault(void* ptr, void* rect)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsColorizeEffect_SourceChanged(void* ptr, long long flags)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}

void QGraphicsColorizeEffect_SourceChangedDefault(void* ptr, long long flags)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}

void QGraphicsColorizeEffect_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsColorizeEffect*>(ptr), "update");
}

void QGraphicsColorizeEffect_UpdateDefault(void* ptr)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::update();
}

void QGraphicsColorizeEffect_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsColorizeEffect_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsColorizeEffect_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsColorizeEffect_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsColorizeEffect_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsColorizeEffect*>(ptr), "deleteLater");
}

void QGraphicsColorizeEffect_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::deleteLater();
}

void QGraphicsColorizeEffect_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsColorizeEffect*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGraphicsColorizeEffect_Event(void* ptr, void* e)
{
	return static_cast<QGraphicsColorizeEffect*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QGraphicsColorizeEffect_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsColorizeEffect*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsColorizeEffect_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsColorizeEffect_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsColorizeEffect*>(ptr)->metaObject());
}

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

class MyQGraphicsDropShadowEffect: public QGraphicsDropShadowEffect
{
public:
	MyQGraphicsDropShadowEffect(QObject *parent) : QGraphicsDropShadowEffect(parent) {};
	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 Signal_BlurRadiusChanged(qreal blurRadius) { callbackQGraphicsDropShadowEffect_BlurRadiusChanged(this, blurRadius); };
	QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsDropShadowEffect_BoundingRectFor(const_cast<MyQGraphicsDropShadowEffect*>(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 setOffset(qreal d) { callbackQGraphicsDropShadowEffect_SetOffset2(this, d); };
	void setOffset(qreal dx, qreal dy) { callbackQGraphicsDropShadowEffect_SetOffset3(this, dx, dy); };
	void setXOffset(qreal dx) { callbackQGraphicsDropShadowEffect_SetXOffset(this, dx); };
	void setYOffset(qreal dy) { callbackQGraphicsDropShadowEffect_SetYOffset(this, dy); };
	void setEnabled(bool enable) { callbackQGraphicsDropShadowEffect_SetEnabled(this, enable); };
	void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsDropShadowEffect_SourceChanged(this, flags); };
	void update() { callbackQGraphicsDropShadowEffect_Update(this); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsDropShadowEffect_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQGraphicsDropShadowEffect_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsDropShadowEffect_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsDropShadowEffect_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsDropShadowEffect_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsDropShadowEffect_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsDropShadowEffect_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsDropShadowEffect_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsDropShadowEffect_MetaObject(const_cast<MyQGraphicsDropShadowEffect*>(this))); };
};

double QGraphicsDropShadowEffect_BlurRadius(void* ptr)
{
	return static_cast<QGraphicsDropShadowEffect*>(ptr)->blurRadius();
}

void* QGraphicsDropShadowEffect_Color(void* ptr)
{
	return new QColor(static_cast<QGraphicsDropShadowEffect*>(ptr)->color());
}

void* QGraphicsDropShadowEffect_Offset(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsDropShadowEffect*>(ptr)->offset(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QGraphicsDropShadowEffect_SetBlurRadius(void* ptr, double blurRadius)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setBlurRadius", Q_ARG(qreal, blurRadius));
}

void QGraphicsDropShadowEffect_SetColor(void* ptr, void* color)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setColor", Q_ARG(QColor, *static_cast<QColor*>(color)));
}

void QGraphicsDropShadowEffect_SetOffset(void* ptr, void* ofs)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setOffset", Q_ARG(QPointF, *static_cast<QPointF*>(ofs)));
}

void* QGraphicsDropShadowEffect_NewQGraphicsDropShadowEffect(void* parent)
{
	return new MyQGraphicsDropShadowEffect(static_cast<QObject*>(parent));
}

void QGraphicsDropShadowEffect_ConnectBlurRadiusChanged(void* ptr)
{
	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));
}

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_BoundingRectFor(void* ptr, void* rect)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsDropShadowEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsDropShadowEffect_BoundingRectForDefault(void* ptr, void* rect)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsDropShadowEffect_ConnectColorChanged(void* ptr)
{
	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));
}

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_ConnectOffsetChanged(void* ptr)
{
	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));
}

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_SetOffset2(void* ptr, double d)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setOffset", Q_ARG(qreal, d));
}

void QGraphicsDropShadowEffect_SetOffset3(void* ptr, double dx, double dy)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setOffset", Q_ARG(qreal, dx), Q_ARG(qreal, dy));
}

void QGraphicsDropShadowEffect_SetXOffset(void* ptr, double dx)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setXOffset", Q_ARG(qreal, dx));
}

void QGraphicsDropShadowEffect_SetYOffset(void* ptr, double dy)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setYOffset", Q_ARG(qreal, 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_SetEnabled(void* ptr, char enable)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setEnabled", Q_ARG(bool, enable != 0));
}

void QGraphicsDropShadowEffect_SetEnabledDefault(void* ptr, char enable)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::setEnabled(enable != 0);
}

void QGraphicsDropShadowEffect_SourceChanged(void* ptr, long long flags)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}

void QGraphicsDropShadowEffect_SourceChangedDefault(void* ptr, long long flags)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}

void QGraphicsDropShadowEffect_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "update");
}

void QGraphicsDropShadowEffect_UpdateDefault(void* ptr)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::update();
}

void QGraphicsDropShadowEffect_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsDropShadowEffect_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsDropShadowEffect_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsDropShadowEffect_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsDropShadowEffect_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "deleteLater");
}

void QGraphicsDropShadowEffect_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::deleteLater();
}

void QGraphicsDropShadowEffect_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsDropShadowEffect*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGraphicsDropShadowEffect_Event(void* ptr, void* e)
{
	return static_cast<QGraphicsDropShadowEffect*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QGraphicsDropShadowEffect_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsDropShadowEffect*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsDropShadowEffect_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsDropShadowEffect_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsDropShadowEffect*>(ptr)->metaObject());
}

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

class MyQGraphicsEffect: public QGraphicsEffect
{
public:
	MyQGraphicsEffect(QObject *parent) : QGraphicsEffect(parent) {};
	void setEnabled(bool enable) { callbackQGraphicsEffect_SetEnabled(this, enable); };
	QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsEffect_BoundingRectFor(const_cast<MyQGraphicsEffect*>(this), const_cast<QRectF*>(&rect))); };
	void draw(QPainter * painter) { callbackQGraphicsEffect_Draw(this, painter); };
	void Signal_EnabledChanged(bool enabled) { callbackQGraphicsEffect_EnabledChanged(this, enabled); };
	void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsEffect_SourceChanged(this, flags); };
	void update() { callbackQGraphicsEffect_Update(this); };
	 ~MyQGraphicsEffect() { callbackQGraphicsEffect_DestroyQGraphicsEffect(this); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsEffect_TimerEvent(this, event); };
	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 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<MyQGraphicsEffect*>(this))); };
};

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_NewQGraphicsEffect(void* parent)
{
	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)
{
	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)
{
	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));
}

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);
}

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)
{
	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_UpdateBoundingRect(void* ptr)
{
	static_cast<QGraphicsEffect*>(ptr)->updateBoundingRect();
}

void QGraphicsEffect_DestroyQGraphicsEffect(void* ptr)
{
	static_cast<QGraphicsEffect*>(ptr)->~QGraphicsEffect();
}

void QGraphicsEffect_DestroyQGraphicsEffectDefault(void* ptr)
{

}

void QGraphicsEffect_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEffect*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsEffect_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEffect*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsEffect_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsEffect*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsEffect_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEffect*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsEffect_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsEffect*>(ptr), "deleteLater");
}

void QGraphicsEffect_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::deleteLater();
}

void QGraphicsEffect_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsEffect*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGraphicsEffect_Event(void* ptr, void* e)
{
	return static_cast<QGraphicsEffect*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QGraphicsEffect_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsEffect*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsEffect_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsEffect_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsEffect*>(ptr)->metaObject());
}

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

class MyQGraphicsEllipseItem: public QGraphicsEllipseItem
{
public:
	MyQGraphicsEllipseItem(qreal x, qreal y, qreal width, qreal height, QGraphicsItem *parent) : QGraphicsEllipseItem(x, y, width, height, parent) {};
	MyQGraphicsEllipseItem(QGraphicsItem *parent) : QGraphicsEllipseItem(parent) {};
	MyQGraphicsEllipseItem(const QRectF &rect, QGraphicsItem *parent) : QGraphicsEllipseItem(rect, parent) {};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsEllipseItem_BoundingRect(const_cast<MyQGraphicsEllipseItem*>(this))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsEllipseItem_Contains(const_cast<MyQGraphicsEllipseItem*>(this), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsEllipseItem_IsObscuredBy(const_cast<MyQGraphicsEllipseItem*>(this), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsEllipseItem_OpaqueArea(const_cast<MyQGraphicsEllipseItem*>(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*>(callbackQGraphicsEllipseItem_Shape(const_cast<MyQGraphicsEllipseItem*>(this))); };
	int type() const { return callbackQGraphicsEllipseItem_Type(const_cast<MyQGraphicsEllipseItem*>(this)); };
	void advance(int phase) { callbackQGraphicsEllipseItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsEllipseItem_CollidesWithItem(const_cast<MyQGraphicsEllipseItem*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsEllipseItem_CollidesWithPath(const_cast<MyQGraphicsEllipseItem*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsEllipseItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsEllipseItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsEllipseItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsEllipseItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsEllipseItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsEllipseItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsEllipseItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsEllipseItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsEllipseItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsEllipseItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsEllipseItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsEllipseItem_InputMethodQuery(const_cast<MyQGraphicsEllipseItem*>(this), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsEllipseItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsEllipseItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsEllipseItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsEllipseItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsEllipseItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsEllipseItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsEllipseItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsEllipseItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsEllipseItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsEllipseItem_WheelEvent(this, event); };
};

void* QGraphicsEllipseItem_NewQGraphicsEllipseItem3(double x, double y, double width, double height, void* parent)
{
	return new MyQGraphicsEllipseItem(x, y, width, height, static_cast<QGraphicsItem*>(parent));
}

void* QGraphicsEllipseItem_NewQGraphicsEllipseItem(void* parent)
{
	return new MyQGraphicsEllipseItem(static_cast<QGraphicsItem*>(parent));
}

void* QGraphicsEllipseItem_NewQGraphicsEllipseItem2(void* rect, void* parent)
{
	return new MyQGraphicsEllipseItem(*static_cast<QRectF*>(rect), 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()); });
}

char QGraphicsEllipseItem_Contains(void* ptr, void* point)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsEllipseItem_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::contains(*static_cast<QPointF*>(point));
}

char QGraphicsEllipseItem_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsEllipseItem_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

void* QGraphicsEllipseItem_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsEllipseItem*>(ptr)->opaqueArea());
}

void* QGraphicsEllipseItem_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::opaqueArea());
}

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);
}

void* QGraphicsEllipseItem_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsEllipseItem*>(ptr)->shape());
}

void* QGraphicsEllipseItem_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::shape());
}

int QGraphicsEllipseItem_SpanAngle(void* ptr)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->spanAngle();
}

int QGraphicsEllipseItem_StartAngle(void* ptr)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->startAngle();
}

int QGraphicsEllipseItem_Type(void* ptr)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->type();
}

int QGraphicsEllipseItem_TypeDefault(void* ptr)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::type();
}

void QGraphicsEllipseItem_DestroyQGraphicsEllipseItem(void* ptr)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->~QGraphicsEllipseItem();
}

void QGraphicsEllipseItem_Advance(void* ptr, int phase)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->advance(phase);
}

void QGraphicsEllipseItem_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::advance(phase);
}

char QGraphicsEllipseItem_CollidesWithItem(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsEllipseItem_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsEllipseItem_CollidesWithPath(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsEllipseItem_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

void QGraphicsEllipseItem_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsEllipseItem_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsEllipseItem_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsEllipseItem_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsEllipseItem_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsEllipseItem_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsEllipseItem_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsEllipseItem_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsEllipseItem_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsEllipseItem_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsEllipseItem_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsEllipseItem_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsEllipseItem_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsEllipseItem_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsEllipseItem_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsEllipseItem_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsEllipseItem_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsEllipseItem_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsEllipseItem_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsEllipseItem_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsEllipseItem_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsEllipseItem_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsEllipseItem_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsEllipseItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsEllipseItem_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsEllipseItem_ItemChange(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsEllipseItem*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsEllipseItem_ItemChangeDefault(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void QGraphicsEllipseItem_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsEllipseItem_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsEllipseItem_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsEllipseItem_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsEllipseItem_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsEllipseItem_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsEllipseItem_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsEllipseItem_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsEllipseItem_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsEllipseItem_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsEllipseItem_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsEllipseItem_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

char QGraphicsEllipseItem_SceneEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsEllipseItem_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsEllipseItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsEllipseItem_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

void QGraphicsEllipseItem_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsEllipseItem_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

class MyQGraphicsGridLayout: public QGraphicsGridLayout
{
public:
	MyQGraphicsGridLayout(QGraphicsLayoutItem *parent) : QGraphicsGridLayout(parent) {};
	int count() const { return callbackQGraphicsGridLayout_Count(const_cast<MyQGraphicsGridLayout*>(this)); };
	void invalidate() { callbackQGraphicsGridLayout_Invalidate(this); };
	QGraphicsLayoutItem * itemAt(int index) const { return static_cast<QGraphicsLayoutItem*>(callbackQGraphicsGridLayout_ItemAt2(const_cast<MyQGraphicsGridLayout*>(this), index)); };
	void removeAt(int index) { callbackQGraphicsGridLayout_RemoveAt(this, index); };
	void setGeometry(const QRectF & rect) { callbackQGraphicsGridLayout_SetGeometry(this, const_cast<QRectF*>(&rect)); };
	QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsGridLayout_SizeHint(const_cast<MyQGraphicsGridLayout*>(this), which, const_cast<QSizeF*>(&constraint))); };
	 ~MyQGraphicsGridLayout() { callbackQGraphicsGridLayout_DestroyQGraphicsGridLayout(this); };
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsGridLayout_GetContentsMargins(const_cast<MyQGraphicsGridLayout*>(this), *left, *top, *right, *bottom); };
	void updateGeometry() { callbackQGraphicsGridLayout_UpdateGeometry(this); };
	void widgetEvent(QEvent * e) { callbackQGraphicsGridLayout_WidgetEvent(this, e); };
};

void* QGraphicsGridLayout_NewQGraphicsGridLayout(void* parent)
{
	return new MyQGraphicsGridLayout(static_cast<QGraphicsLayoutItem*>(parent));
}

void QGraphicsGridLayout_AddItem2(void* ptr, void* item, int row, int column, long long alignment)
{
	static_cast<QGraphicsGridLayout*>(ptr)->addItem(static_cast<QGraphicsLayoutItem*>(item), row, column, static_cast<Qt::AlignmentFlag>(alignment));
}

void QGraphicsGridLayout_AddItem(void* ptr, void* item, int row, int column, int rowSpan, int columnSpan, long long alignment)
{
	static_cast<QGraphicsGridLayout*>(ptr)->addItem(static_cast<QGraphicsLayoutItem*>(item), row, column, rowSpan, columnSpan, static_cast<Qt::AlignmentFlag>(alignment));
}

long long QGraphicsGridLayout_Alignment(void* ptr, void* item)
{
	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_Invalidate(void* ptr)
{
	static_cast<QGraphicsGridLayout*>(ptr)->invalidate();
}

void QGraphicsGridLayout_InvalidateDefault(void* ptr)
{
	static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::invalidate();
}

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

void* QGraphicsGridLayout_ItemAt2Default(void* ptr, int index)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::itemAt(index);
}

void* QGraphicsGridLayout_ItemAt(void* ptr, int row, int column)
{
	return static_cast<QGraphicsGridLayout*>(ptr)->itemAt(row, column);
}

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)
{
	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)
{
	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_SetGeometry(void* ptr, void* rect)
{
	static_cast<QGraphicsGridLayout*>(ptr)->setGeometry(*static_cast<QRectF*>(rect));
}

void QGraphicsGridLayout_SetGeometryDefault(void* ptr, void* rect)
{
	static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::setGeometry(*static_cast<QRectF*>(rect));
}

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)
{

}

void QGraphicsGridLayout_GetContentsMargins(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsGridLayout*>(ptr)->getContentsMargins(&left, &top, &right, &bottom);
}

void QGraphicsGridLayout_GetContentsMarginsDefault(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::getContentsMargins(&left, &top, &right, &bottom);
}

void QGraphicsGridLayout_UpdateGeometry(void* ptr)
{
	static_cast<QGraphicsGridLayout*>(ptr)->updateGeometry();
}

void QGraphicsGridLayout_UpdateGeometryDefault(void* ptr)
{
	static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::updateGeometry();
}

void QGraphicsGridLayout_WidgetEvent(void* ptr, void* e)
{
	static_cast<QGraphicsGridLayout*>(ptr)->widgetEvent(static_cast<QEvent*>(e));
}

void QGraphicsGridLayout_WidgetEventDefault(void* ptr, void* e)
{
	static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::widgetEvent(static_cast<QEvent*>(e));
}

class MyQGraphicsItem: public QGraphicsItem
{
public:
	MyQGraphicsItem(QGraphicsItem *parent) : QGraphicsItem(parent) {};
	void advance(int phase) { callbackQGraphicsItem_Advance(this, phase); };
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsItem_BoundingRect(const_cast<MyQGraphicsItem*>(this))); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<MyQGraphicsItem*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<MyQGraphicsItem*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<MyQGraphicsItem*>(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<MyQGraphicsItem*>(this), query)); };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<MyQGraphicsItem*>(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<MyQGraphicsItem*>(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<MyQGraphicsItem*>(this))); };
	int type() const { return callbackQGraphicsItem_Type(const_cast<MyQGraphicsItem*>(this)); };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, event); };
	 ~MyQGraphicsItem() { callbackQGraphicsItem_DestroyQGraphicsItem(this); };
};

void* QGraphicsItem_NewQGraphicsItem(void* parent)
{
	return new MyQGraphicsItem(static_cast<QGraphicsItem*>(parent));
}

long long QGraphicsItem_AcceptedMouseButtons(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->acceptedMouseButtons();
}

char QGraphicsItem_AcceptDrops(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->acceptDrops();
}

char QGraphicsItem_AcceptHoverEvents(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->acceptHoverEvents();
}

char QGraphicsItem_AcceptTouchEvents(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->acceptTouchEvents();
}

void QGraphicsItem_Advance(void* ptr, int phase)
{
	static_cast<QGraphicsItem*>(ptr)->advance(phase);
}

void QGraphicsItem_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::advance(phase);
}

void* QGraphicsItem_BoundingRect(void* ptr)
{
	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)
{
	return new QRegion(static_cast<QGraphicsItem*>(ptr)->boundingRegion(*static_cast<QTransform*>(itemToDeviceTransform)));
}

double QGraphicsItem_BoundingRegionGranularity(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->boundingRegionGranularity();
}

long long QGraphicsItem_CacheMode(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->cacheMode();
}

void* QGraphicsItem_ChildrenBoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->childrenBoundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsItem_ClearFocus(void* ptr)
{
	static_cast<QGraphicsItem*>(ptr)->clearFocus();
}

void* QGraphicsItem_ClipPath(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->clipPath());
}

char QGraphicsItem_CollidesWithItem(void* ptr, void* other, long long mode)
{
	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)
{
	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)
{
	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)
{
	return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

void* QGraphicsItem_CommonAncestorItem(void* ptr, void* other)
{
	return static_cast<QGraphicsItem*>(ptr)->commonAncestorItem(static_cast<QGraphicsItem*>(other));
}

char QGraphicsItem_Contains(void* ptr, void* point)
{
	return static_cast<QGraphicsItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsItem_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::contains(*static_cast<QPointF*>(point));
}

void QGraphicsItem_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsItem_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void* QGraphicsItem_Cursor(void* ptr)
{
	return new QCursor(static_cast<QGraphicsItem*>(ptr)->cursor());
}

void* QGraphicsItem_Data(void* ptr, int key)
{
	return new QVariant(static_cast<QGraphicsItem*>(ptr)->data(key));
}

void* QGraphicsItem_DeviceTransform(void* ptr, void* viewportTransform)
{
	return new QTransform(static_cast<QGraphicsItem*>(ptr)->deviceTransform(*static_cast<QTransform*>(viewportTransform)));
}

void QGraphicsItem_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItem_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItem_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItem_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItem_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItem_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItem_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItem_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

double QGraphicsItem_EffectiveOpacity(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->effectiveOpacity();
}

void QGraphicsItem_EnsureVisible(void* ptr, void* rect, int xmargin, int ymargin)
{
	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)
{
	static_cast<QGraphicsItem*>(ptr)->ensureVisible(x, y, w, h, xmargin, ymargin);
}

void QGraphicsItem_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsItem_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::focusInEvent(static_cast<QFocusEvent*>(event));
}

void* QGraphicsItem_FocusItem(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->focusItem();
}

void QGraphicsItem_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsItem_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void* QGraphicsItem_FocusProxy(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->focusProxy();
}

char QGraphicsItem_FiltersChildEvents(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->filtersChildEvents();
}

long long QGraphicsItem_Flags(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->flags();
}

void QGraphicsItem_GrabKeyboard(void* ptr)
{
	static_cast<QGraphicsItem*>(ptr)->grabKeyboard();
}

void QGraphicsItem_GrabMouse(void* ptr)
{
	static_cast<QGraphicsItem*>(ptr)->grabMouse();
}

void* QGraphicsItem_GraphicsEffect(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->graphicsEffect();
}

void* QGraphicsItem_Group(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->group();
}

char QGraphicsItem_HasCursor(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->hasCursor();
}

char QGraphicsItem_HasFocus(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->hasFocus();
}

void QGraphicsItem_Hide(void* ptr)
{
	static_cast<QGraphicsItem*>(ptr)->hide();
}

void QGraphicsItem_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsItem_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsItem_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsItem_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsItem_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsItem_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsItem_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsItem_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

long long QGraphicsItem_InputMethodHints(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->inputMethodHints();
}

void* QGraphicsItem_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsItem_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QGraphicsItem_InstallSceneEventFilter(void* ptr, void* filterItem)
{
	static_cast<QGraphicsItem*>(ptr)->installSceneEventFilter(static_cast<QGraphicsItem*>(filterItem));
}

char QGraphicsItem_IsActive(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->isActive();
}

char QGraphicsItem_IsAncestorOf(void* ptr, void* child)
{
	return static_cast<QGraphicsItem*>(ptr)->isAncestorOf(static_cast<QGraphicsItem*>(child));
}

char QGraphicsItem_IsClipped(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->isClipped();
}

char QGraphicsItem_IsEnabled(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->isEnabled();
}

char QGraphicsItem_IsObscured(void* ptr, void* rect)
{
	return static_cast<QGraphicsItem*>(ptr)->isObscured(*static_cast<QRectF*>(rect));
}

char QGraphicsItem_IsObscured2(void* ptr, double x, double y, double w, double h)
{
	return static_cast<QGraphicsItem*>(ptr)->isObscured(x, y, w, h);
}

char QGraphicsItem_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QGraphicsItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsItem_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsItem_IsPanel(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->isPanel();
}

char QGraphicsItem_IsSelected(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->isSelected();
}

char QGraphicsItem_IsUnderMouse(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->isUnderMouse();
}

char QGraphicsItem_IsVisible(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->isVisible();
}

char QGraphicsItem_IsVisibleTo(void* ptr, void* parent)
{
	return static_cast<QGraphicsItem*>(ptr)->isVisibleTo(static_cast<QGraphicsItem*>(parent));
}

char QGraphicsItem_IsWidget(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->isWidget();
}

char QGraphicsItem_IsWindow(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->isWindow();
}

void* QGraphicsItem_ItemChange(void* ptr, long long change, void* value)
{
	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)
{
	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)
{
	return new QTransform(static_cast<QGraphicsItem*>(ptr)->itemTransform(static_cast<QGraphicsItem*>(other), NULL));
}

void QGraphicsItem_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsItem_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsItem_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsItem_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void* QGraphicsItem_MapFromItem4(void* ptr, void* item, void* path)
{
	return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPainterPath*>(path)));
}

void* QGraphicsItem_MapFromItem(void* ptr, void* item, void* point)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsItem_MapFromItem5(void* ptr, void* item, double x, double y)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsItem_MapFromItem3(void* ptr, void* item, void* polygon)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPolygonF*>(polygon)));
}

void* QGraphicsItem_MapFromItem2(void* ptr, void* item, void* rect)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)));
}

void* QGraphicsItem_MapFromItem6(void* ptr, void* item, double x, double y, double w, double h)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), x, y, w, h));
}

void* QGraphicsItem_MapFromParent4(void* ptr, void* path)
{
	return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapFromParent(*static_cast<QPainterPath*>(path)));
}

void* QGraphicsItem_MapFromParent(void* ptr, void* point)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromParent(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsItem_MapFromParent5(void* ptr, double x, double y)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromParent(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsItem_MapFromParent3(void* ptr, void* polygon)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromParent(*static_cast<QPolygonF*>(polygon)));
}

void* QGraphicsItem_MapFromParent2(void* ptr, void* rect)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromParent(*static_cast<QRectF*>(rect)));
}

void* QGraphicsItem_MapFromParent6(void* ptr, double x, double y, double w, double h)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromParent(x, y, w, h));
}

void* QGraphicsItem_MapFromScene4(void* ptr, void* path)
{
	return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapFromScene(*static_cast<QPainterPath*>(path)));
}

void* QGraphicsItem_MapFromScene(void* ptr, void* point)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromScene(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsItem_MapFromScene5(void* ptr, double x, double y)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapFromScene(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsItem_MapFromScene3(void* ptr, void* polygon)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromScene(*static_cast<QPolygonF*>(polygon)));
}

void* QGraphicsItem_MapFromScene2(void* ptr, void* rect)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromScene(*static_cast<QRectF*>(rect)));
}

void* QGraphicsItem_MapFromScene6(void* ptr, double x, double y, double w, double h)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapFromScene(x, y, w, h));
}

void* QGraphicsItem_MapRectFromItem(void* ptr, void* item, void* rect)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapRectToScene(x, y, w, h); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsItem_MapToItem4(void* ptr, void* item, void* path)
{
	return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPainterPath*>(path)));
}

void* QGraphicsItem_MapToItem(void* ptr, void* item, void* point)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsItem_MapToItem5(void* ptr, void* item, double x, double y)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsItem_MapToItem3(void* ptr, void* item, void* polygon)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPolygonF*>(polygon)));
}

void* QGraphicsItem_MapToItem2(void* ptr, void* item, void* rect)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect)));
}

void* QGraphicsItem_MapToItem6(void* ptr, void* item, double x, double y, double w, double h)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), x, y, w, h));
}

void* QGraphicsItem_MapToParent4(void* ptr, void* path)
{
	return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapToParent(*static_cast<QPainterPath*>(path)));
}

void* QGraphicsItem_MapToParent(void* ptr, void* point)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToParent(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsItem_MapToParent5(void* ptr, double x, double y)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToParent(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsItem_MapToParent3(void* ptr, void* polygon)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToParent(*static_cast<QPolygonF*>(polygon)));
}

void* QGraphicsItem_MapToParent2(void* ptr, void* rect)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToParent(*static_cast<QRectF*>(rect)));
}

void* QGraphicsItem_MapToParent6(void* ptr, double x, double y, double w, double h)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToParent(x, y, w, h));
}

void* QGraphicsItem_MapToScene4(void* ptr, void* path)
{
	return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->mapToScene(*static_cast<QPainterPath*>(path)));
}

void* QGraphicsItem_MapToScene(void* ptr, void* point)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToScene(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsItem_MapToScene5(void* ptr, double x, double y)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->mapToScene(x, y); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsItem_MapToScene3(void* ptr, void* polygon)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToScene(*static_cast<QPolygonF*>(polygon)));
}

void* QGraphicsItem_MapToScene2(void* ptr, void* rect)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToScene(*static_cast<QRectF*>(rect)));
}

void* QGraphicsItem_MapToScene6(void* ptr, double x, double y, double w, double h)
{
	return new QPolygonF(static_cast<QGraphicsItem*>(ptr)->mapToScene(x, y, w, h));
}

void QGraphicsItem_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItem_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItem_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItem_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItem_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItem_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItem_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItem_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItem_MoveBy(void* ptr, double dx, double dy)
{
	static_cast<QGraphicsItem*>(ptr)->moveBy(dx, dy);
}

double QGraphicsItem_Opacity(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->opacity();
}

void* QGraphicsItem_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->opaqueArea());
}

void* QGraphicsItem_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::opaqueArea());
}

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

void* QGraphicsItem_Panel(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->panel();
}

long long QGraphicsItem_PanelModality(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->panelModality();
}

void* QGraphicsItem_ParentItem(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->parentItem();
}

void* QGraphicsItem_ParentObject(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->parentObject();
}

void* QGraphicsItem_ParentWidget(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->parentWidget();
}

void* QGraphicsItem_Pos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->pos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QGraphicsItem_PrepareGeometryChange(void* ptr)
{
	static_cast<QGraphicsItem*>(ptr)->prepareGeometryChange();
}

void QGraphicsItem_RemoveSceneEventFilter(void* ptr, void* filterItem)
{
	static_cast<QGraphicsItem*>(ptr)->removeSceneEventFilter(static_cast<QGraphicsItem*>(filterItem));
}

void QGraphicsItem_ResetTransform(void* ptr)
{
	static_cast<QGraphicsItem*>(ptr)->resetTransform();
}

double QGraphicsItem_Rotation(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->rotation();
}

double QGraphicsItem_Scale(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->scale();
}

void* QGraphicsItem_Scene(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->scene();
}

void* QGraphicsItem_SceneBoundingRect(void* ptr)
{
	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)
{
	return static_cast<QGraphicsItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsItem_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsItem_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsItem_ScenePos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->scenePos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsItem_SceneTransform(void* ptr)
{
	return new QTransform(static_cast<QGraphicsItem*>(ptr)->sceneTransform());
}

void QGraphicsItem_Scroll(void* ptr, double dx, double dy, void* rect)
{
	static_cast<QGraphicsItem*>(ptr)->scroll(dx, dy, *static_cast<QRectF*>(rect));
}

void QGraphicsItem_SetAcceptDrops(void* ptr, char on)
{
	static_cast<QGraphicsItem*>(ptr)->setAcceptDrops(on != 0);
}

void QGraphicsItem_SetAcceptHoverEvents(void* ptr, char enabled)
{
	static_cast<QGraphicsItem*>(ptr)->setAcceptHoverEvents(enabled != 0);
}

void QGraphicsItem_SetAcceptTouchEvents(void* ptr, char enabled)
{
	static_cast<QGraphicsItem*>(ptr)->setAcceptTouchEvents(enabled != 0);
}

void QGraphicsItem_SetAcceptedMouseButtons(void* ptr, long long buttons)
{
	static_cast<QGraphicsItem*>(ptr)->setAcceptedMouseButtons(static_cast<Qt::MouseButton>(buttons));
}

void QGraphicsItem_SetActive(void* ptr, char active)
{
	static_cast<QGraphicsItem*>(ptr)->setActive(active != 0);
}

void QGraphicsItem_SetBoundingRegionGranularity(void* ptr, double granularity)
{
	static_cast<QGraphicsItem*>(ptr)->setBoundingRegionGranularity(granularity);
}

void QGraphicsItem_SetCacheMode(void* ptr, long long mode, void* logicalCacheSize)
{
	static_cast<QGraphicsItem*>(ptr)->setCacheMode(static_cast<QGraphicsItem::CacheMode>(mode), *static_cast<QSize*>(logicalCacheSize));
}

void QGraphicsItem_SetCursor(void* ptr, void* cursor)
{
	static_cast<QGraphicsItem*>(ptr)->setCursor(*static_cast<QCursor*>(cursor));
}

void QGraphicsItem_SetData(void* ptr, int key, void* value)
{
	static_cast<QGraphicsItem*>(ptr)->setData(key, *static_cast<QVariant*>(value));
}

void QGraphicsItem_SetEnabled(void* ptr, char enabled)
{
	static_cast<QGraphicsItem*>(ptr)->setEnabled(enabled != 0);
}

void QGraphicsItem_SetFiltersChildEvents(void* ptr, char enabled)
{
	static_cast<QGraphicsItem*>(ptr)->setFiltersChildEvents(enabled != 0);
}

void QGraphicsItem_SetFlag(void* ptr, long long flag, char enabled)
{
	static_cast<QGraphicsItem*>(ptr)->setFlag(static_cast<QGraphicsItem::GraphicsItemFlag>(flag), enabled != 0);
}

void QGraphicsItem_SetFlags(void* ptr, long long flags)
{
	static_cast<QGraphicsItem*>(ptr)->setFlags(static_cast<QGraphicsItem::GraphicsItemFlag>(flags));
}

void QGraphicsItem_SetFocus(void* ptr, long long focusReason)
{
	static_cast<QGraphicsItem*>(ptr)->setFocus(static_cast<Qt::FocusReason>(focusReason));
}

void QGraphicsItem_SetFocusProxy(void* ptr, void* item)
{
	static_cast<QGraphicsItem*>(ptr)->setFocusProxy(static_cast<QGraphicsItem*>(item));
}

void QGraphicsItem_SetGraphicsEffect(void* ptr, void* effect)
{
	static_cast<QGraphicsItem*>(ptr)->setGraphicsEffect(static_cast<QGraphicsEffect*>(effect));
}

void QGraphicsItem_SetGroup(void* ptr, void* group)
{
	static_cast<QGraphicsItem*>(ptr)->setGroup(static_cast<QGraphicsItemGroup*>(group));
}

void QGraphicsItem_SetInputMethodHints(void* ptr, long long hints)
{
	static_cast<QGraphicsItem*>(ptr)->setInputMethodHints(static_cast<Qt::InputMethodHint>(hints));
}

void QGraphicsItem_SetOpacity(void* ptr, double opacity)
{
	static_cast<QGraphicsItem*>(ptr)->setOpacity(opacity);
}

void QGraphicsItem_SetPanelModality(void* ptr, long long panelModality)
{
	static_cast<QGraphicsItem*>(ptr)->setPanelModality(static_cast<QGraphicsItem::PanelModality>(panelModality));
}

void QGraphicsItem_SetParentItem(void* ptr, void* newParent)
{
	static_cast<QGraphicsItem*>(ptr)->setParentItem(static_cast<QGraphicsItem*>(newParent));
}

void QGraphicsItem_SetPos(void* ptr, void* pos)
{
	static_cast<QGraphicsItem*>(ptr)->setPos(*static_cast<QPointF*>(pos));
}

void QGraphicsItem_SetPos2(void* ptr, double x, double y)
{
	static_cast<QGraphicsItem*>(ptr)->setPos(x, y);
}

void QGraphicsItem_SetRotation(void* ptr, double angle)
{
	static_cast<QGraphicsItem*>(ptr)->setRotation(angle);
}

void QGraphicsItem_SetScale(void* ptr, double factor)
{
	static_cast<QGraphicsItem*>(ptr)->setScale(factor);
}

void QGraphicsItem_SetSelected(void* ptr, char selected)
{
	static_cast<QGraphicsItem*>(ptr)->setSelected(selected != 0);
}

void QGraphicsItem_SetToolTip(void* ptr, char* toolTip)
{
	static_cast<QGraphicsItem*>(ptr)->setToolTip(QString(toolTip));
}

void QGraphicsItem_SetTransform(void* ptr, void* matrix, char combine)
{
	static_cast<QGraphicsItem*>(ptr)->setTransform(*static_cast<QTransform*>(matrix), combine != 0);
}

void QGraphicsItem_SetTransformOriginPoint(void* ptr, void* origin)
{
	static_cast<QGraphicsItem*>(ptr)->setTransformOriginPoint(*static_cast<QPointF*>(origin));
}

void QGraphicsItem_SetTransformOriginPoint2(void* ptr, double x, double y)
{
	static_cast<QGraphicsItem*>(ptr)->setTransformOriginPoint(x, y);
}

void QGraphicsItem_SetVisible(void* ptr, char visible)
{
	static_cast<QGraphicsItem*>(ptr)->setVisible(visible != 0);
}

void QGraphicsItem_SetX(void* ptr, double x)
{
	static_cast<QGraphicsItem*>(ptr)->setX(x);
}

void QGraphicsItem_SetY(void* ptr, double y)
{
	static_cast<QGraphicsItem*>(ptr)->setY(y);
}

void QGraphicsItem_SetZValue(void* ptr, double z)
{
	static_cast<QGraphicsItem*>(ptr)->setZValue(z);
}

void* QGraphicsItem_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->shape());
}

void* QGraphicsItem_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::shape());
}

void QGraphicsItem_Show(void* ptr)
{
	static_cast<QGraphicsItem*>(ptr)->show();
}

void QGraphicsItem_StackBefore(void* ptr, void* sibling)
{
	static_cast<QGraphicsItem*>(ptr)->stackBefore(static_cast<QGraphicsItem*>(sibling));
}

void* QGraphicsItem_ToGraphicsObject(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->toGraphicsObject();
}

void* QGraphicsItem_ToGraphicsObject2(void* ptr)
{
	return const_cast<QGraphicsObject*>(static_cast<QGraphicsItem*>(ptr)->toGraphicsObject());
}

char* QGraphicsItem_ToolTip(void* ptr)
{
	return const_cast<char*>(static_cast<QGraphicsItem*>(ptr)->toolTip().toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QGraphicsItem_TopLevelItem(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->topLevelItem();
}

void* QGraphicsItem_TopLevelWidget(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->topLevelWidget();
}

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

void* QGraphicsItem_TransformOriginPoint(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsItem*>(ptr)->transformOriginPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

int QGraphicsItem_Type(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->type();
}

int QGraphicsItem_TypeDefault(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::type();
}

void QGraphicsItem_UngrabKeyboard(void* ptr)
{
	static_cast<QGraphicsItem*>(ptr)->ungrabKeyboard();
}

void QGraphicsItem_UngrabMouse(void* ptr)
{
	static_cast<QGraphicsItem*>(ptr)->ungrabMouse();
}

void QGraphicsItem_UnsetCursor(void* ptr)
{
	static_cast<QGraphicsItem*>(ptr)->unsetCursor();
}

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

void QGraphicsItem_Update2(void* ptr, double x, double y, double width, double height)
{
	static_cast<QGraphicsItem*>(ptr)->update(x, y, width, height);
}

void QGraphicsItem_UpdateMicroFocus(void* ptr)
{
	static_cast<QGraphicsItem*>(ptr)->updateMicroFocus();
}

void QGraphicsItem_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsItem_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void* QGraphicsItem_Window(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->window();
}

double QGraphicsItem_X(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->x();
}

double QGraphicsItem_Y(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->y();
}

double QGraphicsItem_ZValue(void* ptr)
{
	return static_cast<QGraphicsItem*>(ptr)->zValue();
}

void QGraphicsItem_DestroyQGraphicsItem(void* ptr)
{
	static_cast<QGraphicsItem*>(ptr)->~QGraphicsItem();
}

void QGraphicsItem_DestroyQGraphicsItemDefault(void* ptr)
{

}

int QGraphicsItem_QGraphicsItem_UserType()
{
	return QGraphicsItem::UserType;
}

class MyQGraphicsItemGroup: public QGraphicsItemGroup
{
public:
	MyQGraphicsItemGroup(QGraphicsItem *parent) : QGraphicsItemGroup(parent) {};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsItemGroup_BoundingRect(const_cast<MyQGraphicsItemGroup*>(this))); };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItemGroup_IsObscuredBy(const_cast<MyQGraphicsItemGroup*>(this), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItemGroup_OpaqueArea(const_cast<MyQGraphicsItemGroup*>(this))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsItemGroup_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	int type() const { return callbackQGraphicsItemGroup_Type(const_cast<MyQGraphicsItemGroup*>(this)); };
	void advance(int phase) { callbackQGraphicsItemGroup_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItemGroup_CollidesWithItem(const_cast<MyQGraphicsItemGroup*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItemGroup_CollidesWithPath(const_cast<MyQGraphicsItemGroup*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	bool contains(const QPointF & point) const { return callbackQGraphicsItemGroup_Contains(const_cast<MyQGraphicsItemGroup*>(this), const_cast<QPointF*>(&point)) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItemGroup_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItemGroup_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItemGroup_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItemGroup_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItemGroup_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsItemGroup_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItemGroup_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItemGroup_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItemGroup_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItemGroup_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItemGroup_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItemGroup_InputMethodQuery(const_cast<MyQGraphicsItemGroup*>(this), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItemGroup_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItemGroup_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItemGroup_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItemGroup_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItemGroup_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItemGroup_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItemGroup_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsItemGroup_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItemGroup_SceneEventFilter(this, watched, event) != 0; };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItemGroup_Shape(const_cast<MyQGraphicsItemGroup*>(this))); };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItemGroup_WheelEvent(this, event); };
};

void* QGraphicsItemGroup_NewQGraphicsItemGroup(void* parent)
{
	return new MyQGraphicsItemGroup(static_cast<QGraphicsItem*>(parent));
}

void QGraphicsItemGroup_AddToGroup(void* ptr, void* item)
{
	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()); });
}

char QGraphicsItemGroup_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsItemGroup_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

void* QGraphicsItemGroup_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsItemGroup*>(ptr)->opaqueArea());
}

void* QGraphicsItemGroup_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::opaqueArea());
}

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)
{
	static_cast<QGraphicsItemGroup*>(ptr)->removeFromGroup(static_cast<QGraphicsItem*>(item));
}

int QGraphicsItemGroup_Type(void* ptr)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->type();
}

int QGraphicsItemGroup_TypeDefault(void* ptr)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::type();
}

void QGraphicsItemGroup_DestroyQGraphicsItemGroup(void* ptr)
{
	static_cast<QGraphicsItemGroup*>(ptr)->~QGraphicsItemGroup();
}

void QGraphicsItemGroup_Advance(void* ptr, int phase)
{
	static_cast<QGraphicsItemGroup*>(ptr)->advance(phase);
}

void QGraphicsItemGroup_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::advance(phase);
}

char QGraphicsItemGroup_CollidesWithItem(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsItemGroup_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsItemGroup_CollidesWithPath(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsItemGroup_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsItemGroup_Contains(void* ptr, void* point)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsItemGroup_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::contains(*static_cast<QPointF*>(point));
}

void QGraphicsItemGroup_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsItemGroup_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsItemGroup_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItemGroup_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItemGroup_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItemGroup_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItemGroup_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItemGroup_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItemGroup_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItemGroup_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsItemGroup_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsItemGroup_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsItemGroup_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsItemGroup_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsItemGroup_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsItemGroup_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsItemGroup_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsItemGroup_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsItemGroup_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsItemGroup_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsItemGroup_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsItemGroup_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsItemGroup_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsItemGroup*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsItemGroup_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsItemGroup_ItemChange(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsItemGroup*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsItemGroup_ItemChangeDefault(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void QGraphicsItemGroup_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsItemGroup_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsItemGroup_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsItemGroup_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsItemGroup_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItemGroup_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItemGroup_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItemGroup_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItemGroup_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItemGroup_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItemGroup_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsItemGroup_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

char QGraphicsItemGroup_SceneEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsItemGroup_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsItemGroup_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsItemGroup_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsItemGroup_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsItemGroup*>(ptr)->shape());
}

void* QGraphicsItemGroup_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::shape());
}

void QGraphicsItemGroup_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsItemGroup_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

class MyQGraphicsLayout: public QGraphicsLayout
{
public:
	MyQGraphicsLayout(QGraphicsLayoutItem *parent) : QGraphicsLayout(parent) {};
	int count() const { return callbackQGraphicsLayout_Count(const_cast<MyQGraphicsLayout*>(this)); };
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsLayout_GetContentsMargins(const_cast<MyQGraphicsLayout*>(this), *left, *top, *right, *bottom); };
	void invalidate() { callbackQGraphicsLayout_Invalidate(this); };
	QGraphicsLayoutItem * itemAt(int i) const { return static_cast<QGraphicsLayoutItem*>(callbackQGraphicsLayout_ItemAt(const_cast<MyQGraphicsLayout*>(this), i)); };
	void removeAt(int index) { callbackQGraphicsLayout_RemoveAt(this, index); };
	void updateGeometry() { callbackQGraphicsLayout_UpdateGeometry(this); };
	void widgetEvent(QEvent * e) { callbackQGraphicsLayout_WidgetEvent(this, e); };
	void setGeometry(const QRectF & rect) { callbackQGraphicsLayout_SetGeometry(this, const_cast<QRectF*>(&rect)); };
	QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsLayout_SizeHint(const_cast<MyQGraphicsLayout*>(this), which, const_cast<QSizeF*>(&constraint))); };
};

void* QGraphicsLayout_NewQGraphicsLayout(void* parent)
{
	return new MyQGraphicsLayout(static_cast<QGraphicsLayoutItem*>(parent));
}

void QGraphicsLayout_Activate(void* ptr)
{
	static_cast<QGraphicsLayout*>(ptr)->activate();
}

int QGraphicsLayout_Count(void* ptr)
{
	return static_cast<QGraphicsLayout*>(ptr)->count();
}

void QGraphicsLayout_GetContentsMargins(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsLayout*>(ptr)->getContentsMargins(&left, &top, &right, &bottom);
}

void QGraphicsLayout_GetContentsMarginsDefault(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsLayout*>(ptr)->QGraphicsLayout::getContentsMargins(&left, &top, &right, &bottom);
}

void QGraphicsLayout_Invalidate(void* ptr)
{
	static_cast<QGraphicsLayout*>(ptr)->invalidate();
}

void QGraphicsLayout_InvalidateDefault(void* ptr)
{
	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_AddChildLayoutItem(void* ptr, void* layoutItem)
{
	static_cast<QGraphicsLayout*>(ptr)->addChildLayoutItem(static_cast<QGraphicsLayoutItem*>(layoutItem));
}

void QGraphicsLayout_UpdateGeometry(void* ptr)
{
	static_cast<QGraphicsLayout*>(ptr)->updateGeometry();
}

void QGraphicsLayout_UpdateGeometryDefault(void* ptr)
{
	static_cast<QGraphicsLayout*>(ptr)->QGraphicsLayout::updateGeometry();
}

void QGraphicsLayout_WidgetEvent(void* ptr, void* e)
{
	static_cast<QGraphicsLayout*>(ptr)->widgetEvent(static_cast<QEvent*>(e));
}

void QGraphicsLayout_WidgetEventDefault(void* ptr, void* e)
{
	static_cast<QGraphicsLayout*>(ptr)->QGraphicsLayout::widgetEvent(static_cast<QEvent*>(e));
}

void QGraphicsLayout_DestroyQGraphicsLayout(void* ptr)
{
	static_cast<QGraphicsLayout*>(ptr)->~QGraphicsLayout();
}

void QGraphicsLayout_SetGeometry(void* ptr, void* rect)
{
	static_cast<QGraphicsLayout*>(ptr)->setGeometry(*static_cast<QRectF*>(rect));
}

void QGraphicsLayout_SetGeometryDefault(void* ptr, void* rect)
{
	static_cast<QGraphicsLayout*>(ptr)->QGraphicsLayout::setGeometry(*static_cast<QRectF*>(rect));
}

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()); });
}



class MyQGraphicsLayoutItem: public QGraphicsLayoutItem
{
public:
	MyQGraphicsLayoutItem(QGraphicsLayoutItem *parent, bool isLayout) : QGraphicsLayoutItem(parent, isLayout) {};
	void setGeometry(const QRectF & rect) { callbackQGraphicsLayoutItem_SetGeometry(this, const_cast<QRectF*>(&rect)); };
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsLayoutItem_GetContentsMargins(const_cast<MyQGraphicsLayoutItem*>(this), *left, *top, *right, *bottom); };
	QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsLayoutItem_SizeHint(const_cast<MyQGraphicsLayoutItem*>(this), which, const_cast<QSizeF*>(&constraint))); };
	void updateGeometry() { callbackQGraphicsLayoutItem_UpdateGeometry(this); };
	 ~MyQGraphicsLayoutItem() { callbackQGraphicsLayoutItem_DestroyQGraphicsLayoutItem(this); };
};

void* QGraphicsLayoutItem_Geometry(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsLayoutItem*>(ptr)->geometry(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsLayoutItem_SetGeometry(void* ptr, void* rect)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setGeometry(*static_cast<QRectF*>(rect));
}

void QGraphicsLayoutItem_SetGeometryDefault(void* ptr, void* rect)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->QGraphicsLayoutItem::setGeometry(*static_cast<QRectF*>(rect));
}

void* QGraphicsLayoutItem_NewQGraphicsLayoutItem(void* parent, char isLayout)
{
	return new MyQGraphicsLayoutItem(static_cast<QGraphicsLayoutItem*>(parent), isLayout != 0);
}

void* QGraphicsLayoutItem_ContentsRect(void* ptr)
{
	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)
{
	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_GetContentsMargins(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->getContentsMargins(&left, &top, &right, &bottom);
}

void QGraphicsLayoutItem_GetContentsMarginsDefault(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->QGraphicsLayoutItem::getContentsMargins(&left, &top, &right, &bottom);
}

void* QGraphicsLayoutItem_GraphicsItem(void* ptr)
{
	return static_cast<QGraphicsLayoutItem*>(ptr)->graphicsItem();
}

char QGraphicsLayoutItem_IsLayout(void* ptr)
{
	return static_cast<QGraphicsLayoutItem*>(ptr)->isLayout();
}

double QGraphicsLayoutItem_MaximumHeight(void* ptr)
{
	return static_cast<QGraphicsLayoutItem*>(ptr)->maximumHeight();
}

void* QGraphicsLayoutItem_MaximumSize(void* ptr)
{
	return ({ QSizeF tmpValue = static_cast<QGraphicsLayoutItem*>(ptr)->maximumSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

double QGraphicsLayoutItem_MaximumWidth(void* ptr)
{
	return static_cast<QGraphicsLayoutItem*>(ptr)->maximumWidth();
}

double QGraphicsLayoutItem_MinimumHeight(void* ptr)
{
	return static_cast<QGraphicsLayoutItem*>(ptr)->minimumHeight();
}

void* QGraphicsLayoutItem_MinimumSize(void* ptr)
{
	return ({ QSizeF tmpValue = static_cast<QGraphicsLayoutItem*>(ptr)->minimumSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

double QGraphicsLayoutItem_MinimumWidth(void* ptr)
{
	return static_cast<QGraphicsLayoutItem*>(ptr)->minimumWidth();
}

char QGraphicsLayoutItem_OwnedByLayout(void* ptr)
{
	return static_cast<QGraphicsLayoutItem*>(ptr)->ownedByLayout();
}

void* QGraphicsLayoutItem_ParentLayoutItem(void* ptr)
{
	return static_cast<QGraphicsLayoutItem*>(ptr)->parentLayoutItem();
}

double QGraphicsLayoutItem_PreferredHeight(void* ptr)
{
	return static_cast<QGraphicsLayoutItem*>(ptr)->preferredHeight();
}

void* QGraphicsLayoutItem_PreferredSize(void* ptr)
{
	return ({ QSizeF tmpValue = static_cast<QGraphicsLayoutItem*>(ptr)->preferredSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

double QGraphicsLayoutItem_PreferredWidth(void* ptr)
{
	return static_cast<QGraphicsLayoutItem*>(ptr)->preferredWidth();
}

void QGraphicsLayoutItem_SetGraphicsItem(void* ptr, void* item)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setGraphicsItem(static_cast<QGraphicsItem*>(item));
}

void QGraphicsLayoutItem_SetMaximumHeight(void* ptr, double height)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setMaximumHeight(height);
}

void QGraphicsLayoutItem_SetMaximumSize(void* ptr, void* size)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setMaximumSize(*static_cast<QSizeF*>(size));
}

void QGraphicsLayoutItem_SetMaximumSize2(void* ptr, double w, double h)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setMaximumSize(w, h);
}

void QGraphicsLayoutItem_SetMaximumWidth(void* ptr, double width)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setMaximumWidth(width);
}

void QGraphicsLayoutItem_SetMinimumHeight(void* ptr, double height)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setMinimumHeight(height);
}

void QGraphicsLayoutItem_SetMinimumSize(void* ptr, void* size)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setMinimumSize(*static_cast<QSizeF*>(size));
}

void QGraphicsLayoutItem_SetMinimumSize2(void* ptr, double w, double h)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setMinimumSize(w, h);
}

void QGraphicsLayoutItem_SetMinimumWidth(void* ptr, double width)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setMinimumWidth(width);
}

void QGraphicsLayoutItem_SetOwnedByLayout(void* ptr, char ownership)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setOwnedByLayout(ownership != 0);
}

void QGraphicsLayoutItem_SetParentLayoutItem(void* ptr, void* parent)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setParentLayoutItem(static_cast<QGraphicsLayoutItem*>(parent));
}

void QGraphicsLayoutItem_SetPreferredHeight(void* ptr, double height)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setPreferredHeight(height);
}

void QGraphicsLayoutItem_SetPreferredSize(void* ptr, void* size)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setPreferredSize(*static_cast<QSizeF*>(size));
}

void QGraphicsLayoutItem_SetPreferredSize2(void* ptr, double w, double h)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setPreferredSize(w, h);
}

void QGraphicsLayoutItem_SetPreferredWidth(void* ptr, double width)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setPreferredWidth(width);
}

void QGraphicsLayoutItem_SetSizePolicy2(void* ptr, long long hPolicy, long long vPolicy, long long controlType)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setSizePolicy(static_cast<QSizePolicy::Policy>(hPolicy), static_cast<QSizePolicy::Policy>(vPolicy), static_cast<QSizePolicy::ControlType>(controlType));
}

void QGraphicsLayoutItem_SetSizePolicy(void* ptr, void* policy)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->setSizePolicy(*static_cast<QSizePolicy*>(policy));
}

void* QGraphicsLayoutItem_SizeHint(void* ptr, long long which, void* constraint)
{
	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_UpdateGeometry(void* ptr)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->updateGeometry();
}

void QGraphicsLayoutItem_UpdateGeometryDefault(void* ptr)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->QGraphicsLayoutItem::updateGeometry();
}

void QGraphicsLayoutItem_DestroyQGraphicsLayoutItem(void* ptr)
{
	static_cast<QGraphicsLayoutItem*>(ptr)->~QGraphicsLayoutItem();
}

void QGraphicsLayoutItem_DestroyQGraphicsLayoutItemDefault(void* ptr)
{

}

class MyQGraphicsLineItem: public QGraphicsLineItem
{
public:
	MyQGraphicsLineItem(QGraphicsItem *parent) : QGraphicsLineItem(parent) {};
	MyQGraphicsLineItem(const QLineF &line, QGraphicsItem *parent) : QGraphicsLineItem(line, parent) {};
	MyQGraphicsLineItem(qreal x1, qreal y1, qreal x2, qreal y2, QGraphicsItem *parent) : QGraphicsLineItem(x1, y1, x2, y2, parent) {};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsLineItem_BoundingRect(const_cast<MyQGraphicsLineItem*>(this))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsLineItem_Contains(const_cast<MyQGraphicsLineItem*>(this), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsLineItem_IsObscuredBy(const_cast<MyQGraphicsLineItem*>(this), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsLineItem_OpaqueArea(const_cast<MyQGraphicsLineItem*>(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*>(callbackQGraphicsLineItem_Shape(const_cast<MyQGraphicsLineItem*>(this))); };
	int type() const { return callbackQGraphicsLineItem_Type(const_cast<MyQGraphicsLineItem*>(this)); };
	void advance(int phase) { callbackQGraphicsLineItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsLineItem_CollidesWithItem(const_cast<MyQGraphicsLineItem*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsLineItem_CollidesWithPath(const_cast<MyQGraphicsLineItem*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsLineItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsLineItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsLineItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsLineItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsLineItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsLineItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsLineItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsLineItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsLineItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsLineItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsLineItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsLineItem_InputMethodQuery(const_cast<MyQGraphicsLineItem*>(this), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsLineItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsLineItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsLineItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsLineItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsLineItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsLineItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsLineItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsLineItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsLineItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsLineItem_WheelEvent(this, event); };
};

void* QGraphicsLineItem_NewQGraphicsLineItem(void* parent)
{
	return new MyQGraphicsLineItem(static_cast<QGraphicsItem*>(parent));
}

void* QGraphicsLineItem_NewQGraphicsLineItem2(void* line, void* parent)
{
	return new MyQGraphicsLineItem(*static_cast<QLineF*>(line), static_cast<QGraphicsItem*>(parent));
}

void* QGraphicsLineItem_NewQGraphicsLineItem3(double x1, double y1, double x2, double y2, void* parent)
{
	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()); });
}

char QGraphicsLineItem_Contains(void* ptr, void* point)
{
	return static_cast<QGraphicsLineItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsLineItem_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::contains(*static_cast<QPointF*>(point));
}

char QGraphicsLineItem_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QGraphicsLineItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsLineItem_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

void* QGraphicsLineItem_Line(void* ptr)
{
	return ({ QLineF tmpValue = static_cast<QGraphicsLineItem*>(ptr)->line(); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}

void* QGraphicsLineItem_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsLineItem*>(ptr)->opaqueArea());
}

void* QGraphicsLineItem_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::opaqueArea());
}

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_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsLineItem*>(ptr)->shape());
}

void* QGraphicsLineItem_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::shape());
}

int QGraphicsLineItem_Type(void* ptr)
{
	return static_cast<QGraphicsLineItem*>(ptr)->type();
}

int QGraphicsLineItem_TypeDefault(void* ptr)
{
	return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::type();
}

void QGraphicsLineItem_DestroyQGraphicsLineItem(void* ptr)
{
	static_cast<QGraphicsLineItem*>(ptr)->~QGraphicsLineItem();
}

void QGraphicsLineItem_Advance(void* ptr, int phase)
{
	static_cast<QGraphicsLineItem*>(ptr)->advance(phase);
}

void QGraphicsLineItem_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::advance(phase);
}

char QGraphicsLineItem_CollidesWithItem(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsLineItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsLineItem_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsLineItem_CollidesWithPath(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsLineItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsLineItem_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

void QGraphicsLineItem_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsLineItem_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsLineItem_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsLineItem_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsLineItem_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsLineItem_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsLineItem_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsLineItem_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsLineItem_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsLineItem_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsLineItem_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsLineItem_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsLineItem_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsLineItem_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsLineItem_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsLineItem_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsLineItem_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsLineItem_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsLineItem_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsLineItem_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsLineItem_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsLineItem_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsLineItem_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsLineItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsLineItem_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsLineItem_ItemChange(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsLineItem*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsLineItem_ItemChangeDefault(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void QGraphicsLineItem_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsLineItem_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsLineItem_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsLineItem_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsLineItem_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsLineItem_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsLineItem_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsLineItem_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsLineItem_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsLineItem_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsLineItem_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsLineItem_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

char QGraphicsLineItem_SceneEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsLineItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsLineItem_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsLineItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsLineItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsLineItem_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

void QGraphicsLineItem_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsLineItem_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

class MyQGraphicsLinearLayout: public QGraphicsLinearLayout
{
public:
	MyQGraphicsLinearLayout(QGraphicsLayoutItem *parent) : QGraphicsLinearLayout(parent) {};
	MyQGraphicsLinearLayout(Qt::Orientation orientation, QGraphicsLayoutItem *parent) : QGraphicsLinearLayout(orientation, parent) {};
	int count() const { return callbackQGraphicsLinearLayout_Count(const_cast<MyQGraphicsLinearLayout*>(this)); };
	void invalidate() { callbackQGraphicsLinearLayout_Invalidate(this); };
	QGraphicsLayoutItem * itemAt(int index) const { return static_cast<QGraphicsLayoutItem*>(callbackQGraphicsLinearLayout_ItemAt(const_cast<MyQGraphicsLinearLayout*>(this), index)); };
	void removeAt(int index) { callbackQGraphicsLinearLayout_RemoveAt(this, index); };
	void setGeometry(const QRectF & rect) { callbackQGraphicsLinearLayout_SetGeometry(this, const_cast<QRectF*>(&rect)); };
	QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsLinearLayout_SizeHint(const_cast<MyQGraphicsLinearLayout*>(this), which, const_cast<QSizeF*>(&constraint))); };
	 ~MyQGraphicsLinearLayout() { callbackQGraphicsLinearLayout_DestroyQGraphicsLinearLayout(this); };
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsLinearLayout_GetContentsMargins(const_cast<MyQGraphicsLinearLayout*>(this), *left, *top, *right, *bottom); };
	void updateGeometry() { callbackQGraphicsLinearLayout_UpdateGeometry(this); };
	void widgetEvent(QEvent * e) { callbackQGraphicsLinearLayout_WidgetEvent(this, e); };
};

void* QGraphicsLinearLayout_NewQGraphicsLinearLayout(void* parent)
{
	return new MyQGraphicsLinearLayout(static_cast<QGraphicsLayoutItem*>(parent));
}

void* QGraphicsLinearLayout_NewQGraphicsLinearLayout2(long long orientation, void* parent)
{
	return new MyQGraphicsLinearLayout(static_cast<Qt::Orientation>(orientation), static_cast<QGraphicsLayoutItem*>(parent));
}

void QGraphicsLinearLayout_AddItem(void* ptr, void* item)
{
	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)
{
	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)
{
	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_Invalidate(void* ptr)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->invalidate();
}

void QGraphicsLinearLayout_InvalidateDefault(void* ptr)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::invalidate();
}

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)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->removeItem(static_cast<QGraphicsLayoutItem*>(item));
}

void QGraphicsLinearLayout_SetAlignment(void* ptr, void* item, long long alignment)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->setAlignment(static_cast<QGraphicsLayoutItem*>(item), static_cast<Qt::AlignmentFlag>(alignment));
}

void QGraphicsLinearLayout_SetGeometry(void* ptr, void* rect)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->setGeometry(*static_cast<QRectF*>(rect));
}

void QGraphicsLinearLayout_SetGeometryDefault(void* ptr, void* rect)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::setGeometry(*static_cast<QRectF*>(rect));
}

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)
{
	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)
{
	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)
{

}

void QGraphicsLinearLayout_GetContentsMargins(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->getContentsMargins(&left, &top, &right, &bottom);
}

void QGraphicsLinearLayout_GetContentsMarginsDefault(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::getContentsMargins(&left, &top, &right, &bottom);
}

void QGraphicsLinearLayout_UpdateGeometry(void* ptr)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->updateGeometry();
}

void QGraphicsLinearLayout_UpdateGeometryDefault(void* ptr)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::updateGeometry();
}

void QGraphicsLinearLayout_WidgetEvent(void* ptr, void* e)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->widgetEvent(static_cast<QEvent*>(e));
}

void QGraphicsLinearLayout_WidgetEventDefault(void* ptr, void* e)
{
	static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::widgetEvent(static_cast<QEvent*>(e));
}

class MyQGraphicsObject: public QGraphicsObject
{
public:
	MyQGraphicsObject(QGraphicsItem *parent) : QGraphicsObject(parent) {};
	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 timerEvent(QTimerEvent * event) { callbackQGraphicsObject_TimerEvent(this, event); };
	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 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<MyQGraphicsObject*>(this))); };
	void advance(int phase) { callbackQGraphicsObject_Advance(this, phase); };
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsObject_BoundingRect(const_cast<MyQGraphicsObject*>(this))); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsObject_CollidesWithItem(const_cast<MyQGraphicsObject*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsObject_CollidesWithPath(const_cast<MyQGraphicsObject*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	bool contains(const QPointF & point) const { return callbackQGraphicsObject_Contains(const_cast<MyQGraphicsObject*>(this), const_cast<QPointF*>(&point)) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsObject_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsObject_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsObject_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsObject_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsObject_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsObject_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsObject_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsObject_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsObject_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsObject_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsObject_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsObject_InputMethodQuery(const_cast<MyQGraphicsObject*>(this), query)); };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsObject_IsObscuredBy(const_cast<MyQGraphicsObject*>(this), const_cast<QGraphicsItem*>(item)) != 0; };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsObject_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsObject_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsObject_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsObject_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsObject_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsObject_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsObject_MouseReleaseEvent(this, event); };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsObject_OpaqueArea(const_cast<MyQGraphicsObject*>(this))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsObject_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsObject_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsObject_SceneEventFilter(this, watched, event) != 0; };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsObject_Shape(const_cast<MyQGraphicsObject*>(this))); };
	int type() const { return callbackQGraphicsObject_Type(const_cast<MyQGraphicsObject*>(this)); };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsObject_WheelEvent(this, event); };
};

void* QGraphicsObject_NewQGraphicsObject(void* parent)
{
	return new MyQGraphicsObject(static_cast<QGraphicsItem*>(parent));
}

void QGraphicsObject_ConnectEnabledChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::enabledChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_EnabledChanged));
}

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)
{
	static_cast<QGraphicsObject*>(ptr)->enabledChanged();
}

char QGraphicsObject_Event(void* ptr, void* ev)
{
	return static_cast<QGraphicsObject*>(ptr)->event(static_cast<QEvent*>(ev));
}

void QGraphicsObject_GrabGesture(void* ptr, long long gesture, long long flags)
{
	static_cast<QGraphicsObject*>(ptr)->grabGesture(static_cast<Qt::GestureType>(gesture), static_cast<Qt::GestureFlag>(flags));
}

void QGraphicsObject_ConnectOpacityChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::opacityChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_OpacityChanged));
}

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)
{
	static_cast<QGraphicsObject*>(ptr)->opacityChanged();
}

void QGraphicsObject_ConnectParentChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::parentChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_ParentChanged));
}

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)
{
	static_cast<QGraphicsObject*>(ptr)->parentChanged();
}

void QGraphicsObject_ConnectRotationChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::rotationChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_RotationChanged));
}

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)
{
	static_cast<QGraphicsObject*>(ptr)->rotationChanged();
}

void QGraphicsObject_ConnectScaleChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::scaleChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_ScaleChanged));
}

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)
{
	static_cast<QGraphicsObject*>(ptr)->scaleChanged();
}

void QGraphicsObject_UngrabGesture(void* ptr, long long gesture)
{
	static_cast<QGraphicsObject*>(ptr)->ungrabGesture(static_cast<Qt::GestureType>(gesture));
}

void QGraphicsObject_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsObject*>(ptr), "updateMicroFocus");
}

void QGraphicsObject_ConnectVisibleChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::visibleChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_VisibleChanged));
}

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)
{
	static_cast<QGraphicsObject*>(ptr)->visibleChanged();
}

void QGraphicsObject_ConnectXChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::xChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_XChanged));
}

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)
{
	static_cast<QGraphicsObject*>(ptr)->xChanged();
}

void QGraphicsObject_ConnectYChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::yChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_YChanged));
}

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)
{
	static_cast<QGraphicsObject*>(ptr)->yChanged();
}

void QGraphicsObject_ConnectZChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsObject*>(ptr), static_cast<void (QGraphicsObject::*)()>(&QGraphicsObject::zChanged), static_cast<MyQGraphicsObject*>(ptr), static_cast<void (MyQGraphicsObject::*)()>(&MyQGraphicsObject::Signal_ZChanged));
}

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)
{
	static_cast<QGraphicsObject*>(ptr)->zChanged();
}

void QGraphicsObject_DestroyQGraphicsObject(void* ptr)
{
	static_cast<QGraphicsObject*>(ptr)->~QGraphicsObject();
}

void QGraphicsObject_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsObject_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsObject_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsObject*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsObject_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsObject_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsObject*>(ptr), "deleteLater");
}

void QGraphicsObject_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::deleteLater();
}

void QGraphicsObject_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsObject*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGraphicsObject_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsObject*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsObject_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsObject_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsObject*>(ptr)->metaObject());
}

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

void QGraphicsObject_Advance(void* ptr, int phase)
{
	static_cast<QGraphicsObject*>(ptr)->advance(phase);
}

void QGraphicsObject_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::advance(phase);
}

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



char QGraphicsObject_CollidesWithItem(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsObject*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsObject_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsObject_CollidesWithPath(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsObject*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsObject_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsObject_Contains(void* ptr, void* point)
{
	return static_cast<QGraphicsObject*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsObject_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::contains(*static_cast<QPointF*>(point));
}

void QGraphicsObject_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsObject_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsObject_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsObject_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsObject_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsObject_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsObject_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsObject_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsObject_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsObject_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsObject_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsObject_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsObject_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsObject_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsObject_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsObject_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsObject_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsObject_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsObject_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsObject_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsObject_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsObject_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsObject_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsObject*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsObject_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

char QGraphicsObject_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QGraphicsObject*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsObject_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

void* QGraphicsObject_ItemChange(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsObject*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsObject_ItemChangeDefault(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void QGraphicsObject_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsObject_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsObject_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsObject_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsObject_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsObject_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsObject_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsObject_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsObject_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsObject_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsObject_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsObject_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void* QGraphicsObject_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->opaqueArea());
}

void* QGraphicsObject_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::opaqueArea());
}

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



char QGraphicsObject_SceneEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsObject*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsObject_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsObject_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsObject*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsObject_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsObject_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->shape());
}

void* QGraphicsObject_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::shape());
}

int QGraphicsObject_Type(void* ptr)
{
	return static_cast<QGraphicsObject*>(ptr)->type();
}

int QGraphicsObject_TypeDefault(void* ptr)
{
	return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::type();
}

void QGraphicsObject_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsObject_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

class MyQGraphicsOpacityEffect: public QGraphicsOpacityEffect
{
public:
	MyQGraphicsOpacityEffect(QObject *parent) : QGraphicsOpacityEffect(parent) {};
	void setOpacity(qreal opacity) { callbackQGraphicsOpacityEffect_SetOpacity(this, opacity); };
	void setOpacityMask(const QBrush & mask) { callbackQGraphicsOpacityEffect_SetOpacityMask(this, const_cast<QBrush*>(&mask)); };
	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 setEnabled(bool enable) { callbackQGraphicsOpacityEffect_SetEnabled(this, enable); };
	QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsOpacityEffect_BoundingRectFor(const_cast<MyQGraphicsOpacityEffect*>(this), const_cast<QRectF*>(&rect))); };
	void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsOpacityEffect_SourceChanged(this, flags); };
	void update() { callbackQGraphicsOpacityEffect_Update(this); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsOpacityEffect_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQGraphicsOpacityEffect_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsOpacityEffect_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsOpacityEffect_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsOpacityEffect_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsOpacityEffect_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsOpacityEffect_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsOpacityEffect_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsOpacityEffect_MetaObject(const_cast<MyQGraphicsOpacityEffect*>(this))); };
};

double QGraphicsOpacityEffect_Opacity(void* ptr)
{
	return static_cast<QGraphicsOpacityEffect*>(ptr)->opacity();
}

void* QGraphicsOpacityEffect_OpacityMask(void* ptr)
{
	return new QBrush(static_cast<QGraphicsOpacityEffect*>(ptr)->opacityMask());
}

void QGraphicsOpacityEffect_SetOpacity(void* ptr, double opacity)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsOpacityEffect*>(ptr), "setOpacity", Q_ARG(qreal, opacity));
}

void QGraphicsOpacityEffect_SetOpacityMask(void* ptr, void* mask)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsOpacityEffect*>(ptr), "setOpacityMask", Q_ARG(QBrush, *static_cast<QBrush*>(mask)));
}

void* QGraphicsOpacityEffect_NewQGraphicsOpacityEffect(void* parent)
{
	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));
}

void QGraphicsOpacityEffect_ConnectOpacityChanged(void* ptr)
{
	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));
}

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_ConnectOpacityMaskChanged(void* ptr)
{
	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));
}

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_DestroyQGraphicsOpacityEffect(void* ptr)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->~QGraphicsOpacityEffect();
}

void QGraphicsOpacityEffect_SetEnabled(void* ptr, char enable)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsOpacityEffect*>(ptr), "setEnabled", Q_ARG(bool, enable != 0));
}

void QGraphicsOpacityEffect_SetEnabledDefault(void* ptr, char enable)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::setEnabled(enable != 0);
}

void* QGraphicsOpacityEffect_BoundingRectFor(void* ptr, void* rect)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsOpacityEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsOpacityEffect_BoundingRectForDefault(void* ptr, void* rect)
{
	return ({ QRectF tmpValue = static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::boundingRectFor(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QGraphicsOpacityEffect_SourceChanged(void* ptr, long long flags)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}

void QGraphicsOpacityEffect_SourceChangedDefault(void* ptr, long long flags)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}

void QGraphicsOpacityEffect_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsOpacityEffect*>(ptr), "update");
}

void QGraphicsOpacityEffect_UpdateDefault(void* ptr)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::update();
}

void QGraphicsOpacityEffect_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsOpacityEffect_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsOpacityEffect_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsOpacityEffect_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsOpacityEffect_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsOpacityEffect*>(ptr), "deleteLater");
}

void QGraphicsOpacityEffect_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::deleteLater();
}

void QGraphicsOpacityEffect_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsOpacityEffect*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGraphicsOpacityEffect_Event(void* ptr, void* e)
{
	return static_cast<QGraphicsOpacityEffect*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QGraphicsOpacityEffect_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsOpacityEffect*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsOpacityEffect_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsOpacityEffect_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsOpacityEffect*>(ptr)->metaObject());
}

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

class MyQGraphicsPathItem: public QGraphicsPathItem
{
public:
	MyQGraphicsPathItem(QGraphicsItem *parent) : QGraphicsPathItem(parent) {};
	MyQGraphicsPathItem(const QPainterPath &path, QGraphicsItem *parent) : QGraphicsPathItem(path, parent) {};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsPathItem_BoundingRect(const_cast<MyQGraphicsPathItem*>(this))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsPathItem_Contains(const_cast<MyQGraphicsPathItem*>(this), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsPathItem_IsObscuredBy(const_cast<MyQGraphicsPathItem*>(this), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsPathItem_OpaqueArea(const_cast<MyQGraphicsPathItem*>(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*>(callbackQGraphicsPathItem_Shape(const_cast<MyQGraphicsPathItem*>(this))); };
	int type() const { return callbackQGraphicsPathItem_Type(const_cast<MyQGraphicsPathItem*>(this)); };
	void advance(int phase) { callbackQGraphicsPathItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsPathItem_CollidesWithItem(const_cast<MyQGraphicsPathItem*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsPathItem_CollidesWithPath(const_cast<MyQGraphicsPathItem*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsPathItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPathItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPathItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPathItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPathItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsPathItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsPathItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPathItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPathItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPathItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsPathItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsPathItem_InputMethodQuery(const_cast<MyQGraphicsPathItem*>(this), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsPathItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsPathItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsPathItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPathItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPathItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPathItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPathItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsPathItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsPathItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsPathItem_WheelEvent(this, event); };
};

void* QGraphicsPathItem_NewQGraphicsPathItem(void* parent)
{
	return new MyQGraphicsPathItem(static_cast<QGraphicsItem*>(parent));
}

void* QGraphicsPathItem_NewQGraphicsPathItem2(void* path, void* parent)
{
	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()); });
}

char QGraphicsPathItem_Contains(void* ptr, void* point)
{
	return static_cast<QGraphicsPathItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsPathItem_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::contains(*static_cast<QPointF*>(point));
}

char QGraphicsPathItem_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QGraphicsPathItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsPathItem_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

void* QGraphicsPathItem_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsPathItem*>(ptr)->opaqueArea());
}

void* QGraphicsPathItem_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::opaqueArea());
}

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_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsPathItem*>(ptr)->shape());
}

void* QGraphicsPathItem_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::shape());
}

int QGraphicsPathItem_Type(void* ptr)
{
	return static_cast<QGraphicsPathItem*>(ptr)->type();
}

int QGraphicsPathItem_TypeDefault(void* ptr)
{
	return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::type();
}

void QGraphicsPathItem_DestroyQGraphicsPathItem(void* ptr)
{
	static_cast<QGraphicsPathItem*>(ptr)->~QGraphicsPathItem();
}

void QGraphicsPathItem_Advance(void* ptr, int phase)
{
	static_cast<QGraphicsPathItem*>(ptr)->advance(phase);
}

void QGraphicsPathItem_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::advance(phase);
}

char QGraphicsPathItem_CollidesWithItem(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsPathItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsPathItem_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsPathItem_CollidesWithPath(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsPathItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsPathItem_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

void QGraphicsPathItem_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsPathItem_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsPathItem_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPathItem_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPathItem_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPathItem_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPathItem_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPathItem_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPathItem_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPathItem_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPathItem_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsPathItem_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsPathItem_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsPathItem_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsPathItem_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPathItem_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPathItem_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPathItem_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPathItem_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPathItem_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPathItem_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsPathItem_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsPathItem_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsPathItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsPathItem_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsPathItem_ItemChange(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsPathItem*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsPathItem_ItemChangeDefault(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void QGraphicsPathItem_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsPathItem_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsPathItem_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsPathItem_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsPathItem_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPathItem_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPathItem_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPathItem_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPathItem_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPathItem_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPathItem_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPathItem_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

char QGraphicsPathItem_SceneEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsPathItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsPathItem_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsPathItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsPathItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsPathItem_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

void QGraphicsPathItem_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsPathItem_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

class MyQGraphicsPixmapItem: public QGraphicsPixmapItem
{
public:
	MyQGraphicsPixmapItem(QGraphicsItem *parent) : QGraphicsPixmapItem(parent) {};
	MyQGraphicsPixmapItem(const QPixmap &pixmap, QGraphicsItem *parent) : QGraphicsPixmapItem(pixmap, parent) {};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsPixmapItem_BoundingRect(const_cast<MyQGraphicsPixmapItem*>(this))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsPixmapItem_Contains(const_cast<MyQGraphicsPixmapItem*>(this), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsPixmapItem_IsObscuredBy(const_cast<MyQGraphicsPixmapItem*>(this), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsPixmapItem_OpaqueArea(const_cast<MyQGraphicsPixmapItem*>(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*>(callbackQGraphicsPixmapItem_Shape(const_cast<MyQGraphicsPixmapItem*>(this))); };
	int type() const { return callbackQGraphicsPixmapItem_Type(const_cast<MyQGraphicsPixmapItem*>(this)); };
	void advance(int phase) { callbackQGraphicsPixmapItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsPixmapItem_CollidesWithItem(const_cast<MyQGraphicsPixmapItem*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsPixmapItem_CollidesWithPath(const_cast<MyQGraphicsPixmapItem*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsPixmapItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPixmapItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPixmapItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPixmapItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPixmapItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsPixmapItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsPixmapItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPixmapItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPixmapItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPixmapItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsPixmapItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsPixmapItem_InputMethodQuery(const_cast<MyQGraphicsPixmapItem*>(this), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsPixmapItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsPixmapItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsPixmapItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPixmapItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPixmapItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPixmapItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPixmapItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsPixmapItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsPixmapItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsPixmapItem_WheelEvent(this, event); };
};

void* QGraphicsPixmapItem_NewQGraphicsPixmapItem(void* parent)
{
	return new MyQGraphicsPixmapItem(static_cast<QGraphicsItem*>(parent));
}

void* QGraphicsPixmapItem_NewQGraphicsPixmapItem2(void* pixmap, void* parent)
{
	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()); });
}

char QGraphicsPixmapItem_Contains(void* ptr, void* point)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsPixmapItem_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::contains(*static_cast<QPointF*>(point));
}

char QGraphicsPixmapItem_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsPixmapItem_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

void* QGraphicsPixmapItem_Offset(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QGraphicsPixmapItem*>(ptr)->offset(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QGraphicsPixmapItem_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsPixmapItem*>(ptr)->opaqueArea());
}

void* QGraphicsPixmapItem_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::opaqueArea());
}

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));
}

void* QGraphicsPixmapItem_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsPixmapItem*>(ptr)->shape());
}

void* QGraphicsPixmapItem_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::shape());
}

long long QGraphicsPixmapItem_ShapeMode(void* ptr)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->shapeMode();
}

long long QGraphicsPixmapItem_TransformationMode(void* ptr)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->transformationMode();
}

int QGraphicsPixmapItem_Type(void* ptr)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->type();
}

int QGraphicsPixmapItem_TypeDefault(void* ptr)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::type();
}

void QGraphicsPixmapItem_DestroyQGraphicsPixmapItem(void* ptr)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->~QGraphicsPixmapItem();
}

void QGraphicsPixmapItem_Advance(void* ptr, int phase)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->advance(phase);
}

void QGraphicsPixmapItem_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::advance(phase);
}

char QGraphicsPixmapItem_CollidesWithItem(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsPixmapItem_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsPixmapItem_CollidesWithPath(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsPixmapItem_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

void QGraphicsPixmapItem_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsPixmapItem_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsPixmapItem_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPixmapItem_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPixmapItem_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPixmapItem_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPixmapItem_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPixmapItem_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPixmapItem_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPixmapItem_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPixmapItem_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsPixmapItem_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsPixmapItem_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsPixmapItem_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsPixmapItem_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPixmapItem_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPixmapItem_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPixmapItem_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPixmapItem_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPixmapItem_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPixmapItem_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsPixmapItem_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsPixmapItem_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsPixmapItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsPixmapItem_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsPixmapItem_ItemChange(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsPixmapItem*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsPixmapItem_ItemChangeDefault(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void QGraphicsPixmapItem_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsPixmapItem_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsPixmapItem_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsPixmapItem_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsPixmapItem_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPixmapItem_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPixmapItem_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPixmapItem_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPixmapItem_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPixmapItem_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPixmapItem_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPixmapItem_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

char QGraphicsPixmapItem_SceneEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsPixmapItem_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsPixmapItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsPixmapItem_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

void QGraphicsPixmapItem_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsPixmapItem_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

class MyQGraphicsPolygonItem: public QGraphicsPolygonItem
{
public:
	MyQGraphicsPolygonItem(QGraphicsItem *parent) : QGraphicsPolygonItem(parent) {};
	MyQGraphicsPolygonItem(const QPolygonF &polygon, QGraphicsItem *parent) : QGraphicsPolygonItem(polygon, parent) {};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsPolygonItem_BoundingRect(const_cast<MyQGraphicsPolygonItem*>(this))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsPolygonItem_Contains(const_cast<MyQGraphicsPolygonItem*>(this), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsPolygonItem_IsObscuredBy(const_cast<MyQGraphicsPolygonItem*>(this), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsPolygonItem_OpaqueArea(const_cast<MyQGraphicsPolygonItem*>(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*>(callbackQGraphicsPolygonItem_Shape(const_cast<MyQGraphicsPolygonItem*>(this))); };
	int type() const { return callbackQGraphicsPolygonItem_Type(const_cast<MyQGraphicsPolygonItem*>(this)); };
	void advance(int phase) { callbackQGraphicsPolygonItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsPolygonItem_CollidesWithItem(const_cast<MyQGraphicsPolygonItem*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsPolygonItem_CollidesWithPath(const_cast<MyQGraphicsPolygonItem*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsPolygonItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPolygonItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPolygonItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPolygonItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPolygonItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsPolygonItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsPolygonItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPolygonItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPolygonItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPolygonItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsPolygonItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsPolygonItem_InputMethodQuery(const_cast<MyQGraphicsPolygonItem*>(this), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsPolygonItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsPolygonItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsPolygonItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPolygonItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPolygonItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPolygonItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPolygonItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsPolygonItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsPolygonItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsPolygonItem_WheelEvent(this, event); };
};

void* QGraphicsPolygonItem_NewQGraphicsPolygonItem(void* parent)
{
	return new MyQGraphicsPolygonItem(static_cast<QGraphicsItem*>(parent));
}

void* QGraphicsPolygonItem_NewQGraphicsPolygonItem2(void* polygon, void* parent)
{
	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()); });
}

char QGraphicsPolygonItem_Contains(void* ptr, void* point)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsPolygonItem_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::contains(*static_cast<QPointF*>(point));
}

long long QGraphicsPolygonItem_FillRule(void* ptr)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->fillRule();
}

char QGraphicsPolygonItem_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsPolygonItem_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

void* QGraphicsPolygonItem_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsPolygonItem*>(ptr)->opaqueArea());
}

void* QGraphicsPolygonItem_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::opaqueArea());
}

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_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsPolygonItem*>(ptr)->shape());
}

void* QGraphicsPolygonItem_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::shape());
}

int QGraphicsPolygonItem_Type(void* ptr)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->type();
}

int QGraphicsPolygonItem_TypeDefault(void* ptr)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::type();
}

void QGraphicsPolygonItem_DestroyQGraphicsPolygonItem(void* ptr)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->~QGraphicsPolygonItem();
}

void QGraphicsPolygonItem_Advance(void* ptr, int phase)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->advance(phase);
}

void QGraphicsPolygonItem_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::advance(phase);
}

char QGraphicsPolygonItem_CollidesWithItem(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsPolygonItem_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsPolygonItem_CollidesWithPath(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsPolygonItem_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

void QGraphicsPolygonItem_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsPolygonItem_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsPolygonItem_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPolygonItem_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPolygonItem_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPolygonItem_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPolygonItem_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPolygonItem_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPolygonItem_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPolygonItem_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsPolygonItem_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsPolygonItem_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsPolygonItem_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsPolygonItem_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsPolygonItem_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPolygonItem_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPolygonItem_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPolygonItem_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPolygonItem_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPolygonItem_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsPolygonItem_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsPolygonItem_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsPolygonItem_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsPolygonItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsPolygonItem_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsPolygonItem_ItemChange(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsPolygonItem*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsPolygonItem_ItemChangeDefault(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void QGraphicsPolygonItem_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsPolygonItem_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsPolygonItem_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsPolygonItem_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsPolygonItem_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPolygonItem_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPolygonItem_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPolygonItem_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPolygonItem_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPolygonItem_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPolygonItem_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsPolygonItem_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

char QGraphicsPolygonItem_SceneEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsPolygonItem_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsPolygonItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsPolygonItem_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

void QGraphicsPolygonItem_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsPolygonItem_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

class MyQGraphicsProxyWidget: public QGraphicsProxyWidget
{
public:
	MyQGraphicsProxyWidget(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsProxyWidget(parent, wFlags) {};
	QGraphicsProxyWidget * newProxyWidget(const QWidget * child) { return static_cast<QGraphicsProxyWidget*>(callbackQGraphicsProxyWidget_NewProxyWidget(this, const_cast<QWidget*>(child))); };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsProxyWidget_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsProxyWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsProxyWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsProxyWidget_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsProxyWidget_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsProxyWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQGraphicsProxyWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsProxyWidget_FocusOutEvent(this, event); };
	void grabMouseEvent(QEvent * event) { callbackQGraphicsProxyWidget_GrabMouseEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQGraphicsProxyWidget_HideEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsProxyWidget_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsProxyWidget_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsProxyWidget_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsProxyWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsProxyWidget_InputMethodQuery(const_cast<MyQGraphicsProxyWidget*>(this), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsProxyWidget_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsProxyWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsProxyWidget_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsProxyWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsProxyWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsProxyWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsProxyWidget_MouseReleaseEvent(this, event); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsProxyWidget_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	void resizeEvent(QGraphicsSceneResizeEvent * event) { callbackQGraphicsProxyWidget_ResizeEvent(this, event); };
	void setGeometry(const QRectF & rect) { callbackQGraphicsProxyWidget_SetGeometry(this, const_cast<QRectF*>(&rect)); };
	void showEvent(QShowEvent * event) { callbackQGraphicsProxyWidget_ShowEvent(this, event); };
	QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsProxyWidget_SizeHint(const_cast<MyQGraphicsProxyWidget*>(this), which, const_cast<QSizeF*>(&constraint))); };
	int type() const { return callbackQGraphicsProxyWidget_Type(const_cast<MyQGraphicsProxyWidget*>(this)); };
	void ungrabMouseEvent(QEvent * event) { callbackQGraphicsProxyWidget_UngrabMouseEvent(this, event); };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsProxyWidget_WheelEvent(this, event); };
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsProxyWidget_BoundingRect(const_cast<MyQGraphicsProxyWidget*>(this))); };
	void changeEvent(QEvent * event) { callbackQGraphicsProxyWidget_ChangeEvent(this, event); };
	bool close() { return callbackQGraphicsProxyWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQGraphicsProxyWidget_CloseEvent(this, event); };
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsProxyWidget_GetContentsMargins(const_cast<MyQGraphicsProxyWidget*>(this), *left, *top, *right, *bottom); };
	void grabKeyboardEvent(QEvent * event) { callbackQGraphicsProxyWidget_GrabKeyboardEvent(this, event); };
	void initStyleOption(QStyleOption * option) const { callbackQGraphicsProxyWidget_InitStyleOption(const_cast<MyQGraphicsProxyWidget*>(this), option); };
	void moveEvent(QGraphicsSceneMoveEvent * event) { callbackQGraphicsProxyWidget_MoveEvent(this, event); };
	void paintWindowFrame(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsProxyWidget_PaintWindowFrame(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	void polishEvent() { callbackQGraphicsProxyWidget_PolishEvent(this); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsProxyWidget_SceneEvent(this, event) != 0; };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsProxyWidget_Shape(const_cast<MyQGraphicsProxyWidget*>(this))); };
	void ungrabKeyboardEvent(QEvent * event) { callbackQGraphicsProxyWidget_UngrabKeyboardEvent(this, event); };
	void updateGeometry() { callbackQGraphicsProxyWidget_UpdateGeometry(this); };
	bool windowFrameEvent(QEvent * event) { return callbackQGraphicsProxyWidget_WindowFrameEvent(this, event) != 0; };
	Qt::WindowFrameSection windowFrameSectionAt(const QPointF & pos) const { return static_cast<Qt::WindowFrameSection>(callbackQGraphicsProxyWidget_WindowFrameSectionAt(const_cast<MyQGraphicsProxyWidget*>(this), const_cast<QPointF*>(&pos))); };
	void updateMicroFocus() { callbackQGraphicsProxyWidget_UpdateMicroFocus(this); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsProxyWidget_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQGraphicsProxyWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsProxyWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsProxyWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsProxyWidget_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsProxyWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsProxyWidget_MetaObject(const_cast<MyQGraphicsProxyWidget*>(this))); };
	void advance(int phase) { callbackQGraphicsProxyWidget_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsProxyWidget_CollidesWithItem(const_cast<MyQGraphicsProxyWidget*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsProxyWidget_CollidesWithPath(const_cast<MyQGraphicsProxyWidget*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	bool contains(const QPointF & point) const { return callbackQGraphicsProxyWidget_Contains(const_cast<MyQGraphicsProxyWidget*>(this), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsProxyWidget_IsObscuredBy(const_cast<MyQGraphicsProxyWidget*>(this), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsProxyWidget_OpaqueArea(const_cast<MyQGraphicsProxyWidget*>(this))); };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsProxyWidget_SceneEventFilter(this, watched, event) != 0; };
};

void* QGraphicsProxyWidget_NewProxyWidget(void* ptr, void* child)
{
	QGraphicsProxyWidget* returnArg;
	QMetaObject::invokeMethod(static_cast<QGraphicsProxyWidget*>(ptr), "newProxyWidget", Q_RETURN_ARG(QGraphicsProxyWidget*, returnArg), Q_ARG(QWidget*, static_cast<QWidget*>(child)));
	return returnArg;
}

void* QGraphicsProxyWidget_NewQGraphicsProxyWidget(void* parent, long long wFlags)
{
	return new MyQGraphicsProxyWidget(static_cast<QGraphicsItem*>(parent), static_cast<Qt::WindowType>(wFlags));
}

void QGraphicsProxyWidget_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsProxyWidget_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void* QGraphicsProxyWidget_CreateProxyForChildWidget(void* ptr, void* child)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->createProxyForChildWidget(static_cast<QWidget*>(child));
}

void QGraphicsProxyWidget_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsProxyWidget_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsProxyWidget_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsProxyWidget_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsProxyWidget_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsProxyWidget_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsProxyWidget_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsProxyWidget_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

char QGraphicsProxyWidget_Event(void* ptr, void* event)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->event(static_cast<QEvent*>(event));
}

char QGraphicsProxyWidget_EventFilter(void* ptr, void* object, void* event)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->eventFilter(static_cast<QObject*>(object), static_cast<QEvent*>(event));
}

void QGraphicsProxyWidget_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsProxyWidget_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QGraphicsProxyWidget_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QGraphicsProxyWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::focusNextPrevChild(next != 0);
}

void QGraphicsProxyWidget_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsProxyWidget_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsProxyWidget_GrabMouseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->grabMouseEvent(static_cast<QEvent*>(event));
}

void QGraphicsProxyWidget_GrabMouseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::grabMouseEvent(static_cast<QEvent*>(event));
}

void QGraphicsProxyWidget_HideEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QGraphicsProxyWidget_HideEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::hideEvent(static_cast<QHideEvent*>(event));
}

void QGraphicsProxyWidget_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsProxyWidget_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsProxyWidget_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsProxyWidget_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsProxyWidget_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsProxyWidget_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsProxyWidget_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsProxyWidget_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsProxyWidget_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsProxyWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsProxyWidget_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsProxyWidget_ItemChange(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsProxyWidget*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsProxyWidget_ItemChangeDefault(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void QGraphicsProxyWidget_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsProxyWidget_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsProxyWidget_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsProxyWidget_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsProxyWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsProxyWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsProxyWidget_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsProxyWidget_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsProxyWidget_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsProxyWidget_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsProxyWidget_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsProxyWidget_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

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

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

void QGraphicsProxyWidget_ResizeEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->resizeEvent(static_cast<QGraphicsSceneResizeEvent*>(event));
}

void QGraphicsProxyWidget_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::resizeEvent(static_cast<QGraphicsSceneResizeEvent*>(event));
}

void QGraphicsProxyWidget_SetGeometry(void* ptr, void* rect)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->setGeometry(*static_cast<QRectF*>(rect));
}

void QGraphicsProxyWidget_SetGeometryDefault(void* ptr, void* rect)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::setGeometry(*static_cast<QRectF*>(rect));
}

void QGraphicsProxyWidget_SetWidget(void* ptr, void* widget)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->setWidget(static_cast<QWidget*>(widget));
}

void QGraphicsProxyWidget_ShowEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QGraphicsProxyWidget_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::showEvent(static_cast<QShowEvent*>(event));
}

void* QGraphicsProxyWidget_SizeHint(void* ptr, long long which, void* constraint)
{
	return ({ QSizeF tmpValue = static_cast<QGraphicsProxyWidget*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsProxyWidget_SizeHintDefault(void* ptr, long long which, void* constraint)
{
	return ({ QSizeF tmpValue = static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

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()); });
}

int QGraphicsProxyWidget_Type(void* ptr)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->type();
}

int QGraphicsProxyWidget_TypeDefault(void* ptr)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::type();
}

void QGraphicsProxyWidget_UngrabMouseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->ungrabMouseEvent(static_cast<QEvent*>(event));
}

void QGraphicsProxyWidget_UngrabMouseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::ungrabMouseEvent(static_cast<QEvent*>(event));
}

void QGraphicsProxyWidget_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsProxyWidget_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void* QGraphicsProxyWidget_Widget(void* ptr)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->widget();
}

void QGraphicsProxyWidget_DestroyQGraphicsProxyWidget(void* ptr)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->~QGraphicsProxyWidget();
}

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

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

void QGraphicsProxyWidget_ChangeEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QGraphicsProxyWidget_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::changeEvent(static_cast<QEvent*>(event));
}

char QGraphicsProxyWidget_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QGraphicsProxyWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QGraphicsProxyWidget_CloseDefault(void* ptr)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::close();
}

void QGraphicsProxyWidget_CloseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QGraphicsProxyWidget_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::closeEvent(static_cast<QCloseEvent*>(event));
}

void QGraphicsProxyWidget_GetContentsMargins(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->getContentsMargins(&left, &top, &right, &bottom);
}

void QGraphicsProxyWidget_GetContentsMarginsDefault(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::getContentsMargins(&left, &top, &right, &bottom);
}

void QGraphicsProxyWidget_GrabKeyboardEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->grabKeyboardEvent(static_cast<QEvent*>(event));
}

void QGraphicsProxyWidget_GrabKeyboardEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::grabKeyboardEvent(static_cast<QEvent*>(event));
}

void QGraphicsProxyWidget_InitStyleOption(void* ptr, void* option)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->initStyleOption(static_cast<QStyleOption*>(option));
}

void QGraphicsProxyWidget_InitStyleOptionDefault(void* ptr, void* option)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::initStyleOption(static_cast<QStyleOption*>(option));
}

void QGraphicsProxyWidget_MoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->moveEvent(static_cast<QGraphicsSceneMoveEvent*>(event));
}

void QGraphicsProxyWidget_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::moveEvent(static_cast<QGraphicsSceneMoveEvent*>(event));
}

void QGraphicsProxyWidget_PaintWindowFrame(void* ptr, void* painter, void* option, void* widget)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->paintWindowFrame(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsProxyWidget_PaintWindowFrameDefault(void* ptr, void* painter, void* option, void* widget)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::paintWindowFrame(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsProxyWidget_PolishEvent(void* ptr)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->polishEvent();
}

void QGraphicsProxyWidget_PolishEventDefault(void* ptr)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::polishEvent();
}

char QGraphicsProxyWidget_SceneEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsProxyWidget_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::sceneEvent(static_cast<QEvent*>(event));
}

void* QGraphicsProxyWidget_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsProxyWidget*>(ptr)->shape());
}

void* QGraphicsProxyWidget_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::shape());
}

void QGraphicsProxyWidget_UngrabKeyboardEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->ungrabKeyboardEvent(static_cast<QEvent*>(event));
}

void QGraphicsProxyWidget_UngrabKeyboardEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::ungrabKeyboardEvent(static_cast<QEvent*>(event));
}

void QGraphicsProxyWidget_UpdateGeometry(void* ptr)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->updateGeometry();
}

void QGraphicsProxyWidget_UpdateGeometryDefault(void* ptr)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::updateGeometry();
}

char QGraphicsProxyWidget_WindowFrameEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->windowFrameEvent(static_cast<QEvent*>(event));
}

char QGraphicsProxyWidget_WindowFrameEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::windowFrameEvent(static_cast<QEvent*>(event));
}

long long QGraphicsProxyWidget_WindowFrameSectionAt(void* ptr, void* pos)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->windowFrameSectionAt(*static_cast<QPointF*>(pos));
}

long long QGraphicsProxyWidget_WindowFrameSectionAtDefault(void* ptr, void* pos)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::windowFrameSectionAt(*static_cast<QPointF*>(pos));
}

void QGraphicsProxyWidget_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsProxyWidget*>(ptr), "updateMicroFocus");
}

void QGraphicsProxyWidget_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::updateMicroFocus();
}

void QGraphicsProxyWidget_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsProxyWidget_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsProxyWidget_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsProxyWidget_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsProxyWidget_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsProxyWidget*>(ptr), "deleteLater");
}

void QGraphicsProxyWidget_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::deleteLater();
}

void QGraphicsProxyWidget_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void* QGraphicsProxyWidget_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsProxyWidget*>(ptr)->metaObject());
}

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

void QGraphicsProxyWidget_Advance(void* ptr, int phase)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->advance(phase);
}

void QGraphicsProxyWidget_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::advance(phase);
}

char QGraphicsProxyWidget_CollidesWithItem(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsProxyWidget_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsProxyWidget_CollidesWithPath(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsProxyWidget_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsProxyWidget_Contains(void* ptr, void* point)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsProxyWidget_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::contains(*static_cast<QPointF*>(point));
}

char QGraphicsProxyWidget_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsProxyWidget_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

void* QGraphicsProxyWidget_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsProxyWidget*>(ptr)->opaqueArea());
}

void* QGraphicsProxyWidget_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::opaqueArea());
}

char QGraphicsProxyWidget_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsProxyWidget_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

class MyQGraphicsRectItem: public QGraphicsRectItem
{
public:
	MyQGraphicsRectItem(qreal x, qreal y, qreal width, qreal height, QGraphicsItem *parent) : QGraphicsRectItem(x, y, width, height, parent) {};
	MyQGraphicsRectItem(QGraphicsItem *parent) : QGraphicsRectItem(parent) {};
	MyQGraphicsRectItem(const QRectF &rect, QGraphicsItem *parent) : QGraphicsRectItem(rect, parent) {};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsRectItem_BoundingRect(const_cast<MyQGraphicsRectItem*>(this))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsRectItem_Contains(const_cast<MyQGraphicsRectItem*>(this), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsRectItem_IsObscuredBy(const_cast<MyQGraphicsRectItem*>(this), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsRectItem_OpaqueArea(const_cast<MyQGraphicsRectItem*>(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*>(callbackQGraphicsRectItem_Shape(const_cast<MyQGraphicsRectItem*>(this))); };
	int type() const { return callbackQGraphicsRectItem_Type(const_cast<MyQGraphicsRectItem*>(this)); };
	void advance(int phase) { callbackQGraphicsRectItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsRectItem_CollidesWithItem(const_cast<MyQGraphicsRectItem*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsRectItem_CollidesWithPath(const_cast<MyQGraphicsRectItem*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsRectItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsRectItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsRectItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsRectItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsRectItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsRectItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsRectItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsRectItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsRectItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsRectItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsRectItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsRectItem_InputMethodQuery(const_cast<MyQGraphicsRectItem*>(this), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsRectItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsRectItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsRectItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsRectItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsRectItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsRectItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsRectItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsRectItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsRectItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsRectItem_WheelEvent(this, event); };
};

void* QGraphicsRectItem_NewQGraphicsRectItem3(double x, double y, double width, double height, void* parent)
{
	return new MyQGraphicsRectItem(x, y, width, height, static_cast<QGraphicsItem*>(parent));
}

void QGraphicsRectItem_SetRect(void* ptr, void* rectangle)
{
	static_cast<QGraphicsRectItem*>(ptr)->setRect(*static_cast<QRectF*>(rectangle));
}

void* QGraphicsRectItem_NewQGraphicsRectItem(void* parent)
{
	return new MyQGraphicsRectItem(static_cast<QGraphicsItem*>(parent));
}

void* QGraphicsRectItem_NewQGraphicsRectItem2(void* rect, void* parent)
{
	return new MyQGraphicsRectItem(*static_cast<QRectF*>(rect), 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()); });
}

char QGraphicsRectItem_Contains(void* ptr, void* point)
{
	return static_cast<QGraphicsRectItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsRectItem_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::contains(*static_cast<QPointF*>(point));
}

char QGraphicsRectItem_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QGraphicsRectItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsRectItem_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

void* QGraphicsRectItem_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsRectItem*>(ptr)->opaqueArea());
}

void* QGraphicsRectItem_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::opaqueArea());
}

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_SetRect2(void* ptr, double x, double y, double width, double height)
{
	static_cast<QGraphicsRectItem*>(ptr)->setRect(x, y, width, height);
}

void* QGraphicsRectItem_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsRectItem*>(ptr)->shape());
}

void* QGraphicsRectItem_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::shape());
}

int QGraphicsRectItem_Type(void* ptr)
{
	return static_cast<QGraphicsRectItem*>(ptr)->type();
}

int QGraphicsRectItem_TypeDefault(void* ptr)
{
	return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::type();
}

void QGraphicsRectItem_DestroyQGraphicsRectItem(void* ptr)
{
	static_cast<QGraphicsRectItem*>(ptr)->~QGraphicsRectItem();
}

void QGraphicsRectItem_Advance(void* ptr, int phase)
{
	static_cast<QGraphicsRectItem*>(ptr)->advance(phase);
}

void QGraphicsRectItem_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::advance(phase);
}

char QGraphicsRectItem_CollidesWithItem(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsRectItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsRectItem_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsRectItem_CollidesWithPath(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsRectItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsRectItem_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

void QGraphicsRectItem_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsRectItem_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsRectItem_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsRectItem_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsRectItem_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsRectItem_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsRectItem_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsRectItem_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsRectItem_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsRectItem_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsRectItem_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsRectItem_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsRectItem_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsRectItem_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsRectItem_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsRectItem_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsRectItem_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsRectItem_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsRectItem_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsRectItem_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsRectItem_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsRectItem_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsRectItem_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsRectItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsRectItem_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsRectItem_ItemChange(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsRectItem*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsRectItem_ItemChangeDefault(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void QGraphicsRectItem_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsRectItem_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsRectItem_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsRectItem_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsRectItem_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsRectItem_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsRectItem_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsRectItem_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsRectItem_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsRectItem_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsRectItem_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsRectItem_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

char QGraphicsRectItem_SceneEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsRectItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsRectItem_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsRectItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsRectItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsRectItem_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

void QGraphicsRectItem_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsRectItem_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

class MyQGraphicsRotation: public QGraphicsRotation
{
public:
	MyQGraphicsRotation(QObject *parent) : QGraphicsRotation(parent) {};
	void Signal_AngleChanged() { callbackQGraphicsRotation_AngleChanged(this); };
	void applyTo(QMatrix4x4 * matrix) const { callbackQGraphicsRotation_ApplyTo(const_cast<MyQGraphicsRotation*>(this), matrix); };
	void Signal_AxisChanged() { callbackQGraphicsRotation_AxisChanged(this); };
	void Signal_OriginChanged() { callbackQGraphicsRotation_OriginChanged(this); };
	void update() { callbackQGraphicsRotation_Update(this); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsRotation_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQGraphicsRotation_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsRotation_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsRotation_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsRotation_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsRotation_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsRotation_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsRotation_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsRotation_MetaObject(const_cast<MyQGraphicsRotation*>(this))); };
};

double QGraphicsRotation_Angle(void* ptr)
{
	return static_cast<QGraphicsRotation*>(ptr)->angle();
}

void QGraphicsRotation_SetAngle(void* ptr, double vqr)
{
	static_cast<QGraphicsRotation*>(ptr)->setAngle(vqr);
}

void QGraphicsRotation_SetAxis2(void* ptr, long long axis)
{
	static_cast<QGraphicsRotation*>(ptr)->setAxis(static_cast<Qt::Axis>(axis));
}

void QGraphicsRotation_SetAxis(void* ptr, void* axis)
{
	static_cast<QGraphicsRotation*>(ptr)->setAxis(*static_cast<QVector3D*>(axis));
}

void QGraphicsRotation_SetOrigin(void* ptr, void* point)
{
	static_cast<QGraphicsRotation*>(ptr)->setOrigin(*static_cast<QVector3D*>(point));
}

void* QGraphicsRotation_NewQGraphicsRotation(void* parent)
{
	return new MyQGraphicsRotation(static_cast<QObject*>(parent));
}

void QGraphicsRotation_ConnectAngleChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsRotation*>(ptr), static_cast<void (QGraphicsRotation::*)()>(&QGraphicsRotation::angleChanged), static_cast<MyQGraphicsRotation*>(ptr), static_cast<void (MyQGraphicsRotation::*)()>(&MyQGraphicsRotation::Signal_AngleChanged));
}

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_ConnectAxisChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsRotation*>(ptr), static_cast<void (QGraphicsRotation::*)()>(&QGraphicsRotation::axisChanged), static_cast<MyQGraphicsRotation*>(ptr), static_cast<void (MyQGraphicsRotation::*)()>(&MyQGraphicsRotation::Signal_AxisChanged));
}

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_ConnectOriginChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsRotation*>(ptr), static_cast<void (QGraphicsRotation::*)()>(&QGraphicsRotation::originChanged), static_cast<MyQGraphicsRotation*>(ptr), static_cast<void (MyQGraphicsRotation::*)()>(&MyQGraphicsRotation::Signal_OriginChanged));
}

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_DestroyQGraphicsRotation(void* ptr)
{
	static_cast<QGraphicsRotation*>(ptr)->~QGraphicsRotation();
}

void QGraphicsRotation_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsRotation*>(ptr), "update");
}

void QGraphicsRotation_UpdateDefault(void* ptr)
{
	static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::update();
}

void QGraphicsRotation_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRotation*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsRotation_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRotation*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsRotation_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsRotation*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsRotation_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsRotation*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsRotation_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsRotation*>(ptr), "deleteLater");
}

void QGraphicsRotation_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::deleteLater();
}

void QGraphicsRotation_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsRotation*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGraphicsRotation_Event(void* ptr, void* e)
{
	return static_cast<QGraphicsRotation*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QGraphicsRotation_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsRotation*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsRotation_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsRotation_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsRotation*>(ptr)->metaObject());
}

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

class MyQGraphicsScale: public QGraphicsScale
{
public:
	MyQGraphicsScale(QObject *parent) : QGraphicsScale(parent) {};
	void applyTo(QMatrix4x4 * matrix) const { callbackQGraphicsScale_ApplyTo(const_cast<MyQGraphicsScale*>(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); };
	void update() { callbackQGraphicsScale_Update(this); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsScale_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQGraphicsScale_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsScale_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsScale_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsScale_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsScale_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGraphicsScale_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsScale_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsScale_MetaObject(const_cast<MyQGraphicsScale*>(this))); };
};

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();
}

double QGraphicsScale_YScale(void* ptr)
{
	return static_cast<QGraphicsScale*>(ptr)->yScale();
}

double QGraphicsScale_ZScale(void* ptr)
{
	return static_cast<QGraphicsScale*>(ptr)->zScale();
}

void* QGraphicsScale_NewQGraphicsScale(void* parent)
{
	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_ConnectOriginChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::originChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_OriginChanged));
}

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)
{
	QObject::connect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::scaleChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_ScaleChanged));
}

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_ConnectXScaleChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::xScaleChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_XScaleChanged));
}

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();
}

void QGraphicsScale_ConnectYScaleChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::yScaleChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_YScaleChanged));
}

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();
}

void QGraphicsScale_ConnectZScaleChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsScale*>(ptr), static_cast<void (QGraphicsScale::*)()>(&QGraphicsScale::zScaleChanged), static_cast<MyQGraphicsScale*>(ptr), static_cast<void (MyQGraphicsScale::*)()>(&MyQGraphicsScale::Signal_ZScaleChanged));
}

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_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsScale*>(ptr), "update");
}

void QGraphicsScale_UpdateDefault(void* ptr)
{
	static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::update();
}

void QGraphicsScale_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsScale*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsScale_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsScale*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsScale_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsScale*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsScale_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsScale*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsScale_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsScale*>(ptr), "deleteLater");
}

void QGraphicsScale_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::deleteLater();
}

void QGraphicsScale_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsScale*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGraphicsScale_Event(void* ptr, void* e)
{
	return static_cast<QGraphicsScale*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QGraphicsScale_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsScale*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsScale_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsScale_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsScale*>(ptr)->metaObject());
}

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

class MyQGraphicsScene: public QGraphicsScene
{
public:
	MyQGraphicsScene(QObject *parent) : QGraphicsScene(parent) {};
	MyQGraphicsScene(const QRectF &sceneRect, QObject *parent) : QGraphicsScene(sceneRect, parent) {};
	MyQGraphicsScene(qreal x, qreal y, qreal width, qreal height, QObject *parent) : QGraphicsScene(x, y, width, height, parent) {};
	void update(const QRectF & rect) { callbackQGraphicsScene_Update(this, const_cast<QRectF*>(&rect)); };
	void advance() { callbackQGraphicsScene_Advance(this); };
	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); };
	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<MyQGraphicsScene*>(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 wheelEvent(QGraphicsSceneWheelEvent * wheelEvent) { callbackQGraphicsScene_WheelEvent(this, wheelEvent); };
	 ~MyQGraphicsScene() { callbackQGraphicsScene_DestroyQGraphicsScene(this); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsScene_TimerEvent(this, event); };
	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 disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsScene_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsScene_MetaObject(const_cast<MyQGraphicsScene*>(this))); };
};

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_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_IsSortCacheEnabled(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->isSortCacheEnabled();
}

long long QGraphicsScene_ItemIndexMethod(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->itemIndexMethod();
}

double QGraphicsScene_MinimumRenderSize(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->minimumRenderSize();
}

void* QGraphicsScene_Palette(void* ptr)
{
	return new QPalette(static_cast<QGraphicsScene*>(ptr)->palette());
}

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_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_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_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);
}

char QGraphicsScene_StickyFocus(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->stickyFocus();
}

void QGraphicsScene_Update(void* ptr, void* rect)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsScene*>(ptr), "update", Q_ARG(QRectF, *static_cast<QRectF*>(rect)));
}

void* QGraphicsScene_NewQGraphicsScene(void* parent)
{
	return new MyQGraphicsScene(static_cast<QObject*>(parent));
}

void* QGraphicsScene_NewQGraphicsScene2(void* sceneRect, void* parent)
{
	return new MyQGraphicsScene(*static_cast<QRectF*>(sceneRect), static_cast<QObject*>(parent));
}

void* QGraphicsScene_NewQGraphicsScene3(double x, double y, double width, double height, void* parent)
{
	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)
{
	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, char* text, void* font)
{
	return static_cast<QGraphicsScene*>(ptr)->addSimpleText(QString(text), *static_cast<QFont*>(font));
}

void* QGraphicsScene_AddText(void* ptr, char* text, void* font)
{
	return static_cast<QGraphicsScene*>(ptr)->addText(QString(text), *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_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsScene*>(ptr), "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_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_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_Event(void* ptr, void* event)
{
	return static_cast<QGraphicsScene*>(ptr)->event(static_cast<QEvent*>(event));
}

char QGraphicsScene_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsScene*>(ptr)->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)
{
	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));
}

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)
{
	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);
}

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));
}

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(QRectF, *static_cast<QRectF*>(rect)), Q_ARG(QGraphicsScene::SceneLayer, 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();
}

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));
}

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));
}

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_RemoveItem(void* ptr, void* item)
{
	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_ConnectSceneRectChanged(void* ptr)
{
	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));
}

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));
}

void* QGraphicsScene_SelectionArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsScene*>(ptr)->selectionArea());
}

void QGraphicsScene_ConnectSelectionChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsScene*>(ptr), static_cast<void (QGraphicsScene::*)()>(&QGraphicsScene::selectionChanged), static_cast<MyQGraphicsScene*>(ptr), static_cast<void (MyQGraphicsScene::*)()>(&MyQGraphicsScene::Signal_SelectionChanged));
}

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)
{
	return static_cast<QGraphicsScene*>(ptr)->sendEvent(static_cast<QGraphicsItem*>(item), static_cast<QEvent*>(event));
}

void QGraphicsScene_SetActivePanel(void* ptr, void* item)
{
	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_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)
{
	static_cast<QGraphicsScene*>(ptr)->setFocusItem(static_cast<QGraphicsItem*>(item), static_cast<Qt::FocusReason>(focusReason));
}

void QGraphicsScene_SetSceneRect2(void* ptr, double x, double y, double w, double h)
{
	static_cast<QGraphicsScene*>(ptr)->setSceneRect(x, y, w, h);
}

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_SetSelectionArea(void* ptr, void* path, void* deviceTransform)
{
	static_cast<QGraphicsScene*>(ptr)->setSelectionArea(*static_cast<QPainterPath*>(path), *static_cast<QTransform*>(deviceTransform));
}

void QGraphicsScene_SetStyle(void* ptr, void* style)
{
	static_cast<QGraphicsScene*>(ptr)->setStyle(static_cast<QStyle*>(style));
}

void* QGraphicsScene_Style(void* ptr)
{
	return static_cast<QGraphicsScene*>(ptr)->style();
}

void QGraphicsScene_Update2(void* ptr, double x, double y, double w, double h)
{
	static_cast<QGraphicsScene*>(ptr)->update(x, y, w, h);
}

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)
{

}

void QGraphicsScene_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsScene*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsScene_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsScene*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsScene_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsScene*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsScene_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsScene*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsScene_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsScene*>(ptr), "deleteLater");
}

void QGraphicsScene_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::deleteLater();
}

void QGraphicsScene_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsScene*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void* QGraphicsScene_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsScene*>(ptr)->metaObject());
}

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

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 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* QGraphicsSceneEvent_Widget(void* ptr)
{
	return static_cast<QGraphicsSceneEvent*>(ptr)->widget();
}

void QGraphicsSceneEvent_DestroyQGraphicsSceneEvent(void* ptr)
{
	static_cast<QGraphicsSceneEvent*>(ptr)->~QGraphicsSceneEvent();
}

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* 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();
}

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* QGraphicsSceneMoveEvent_NewQGraphicsSceneMoveEvent()
{
	return new QGraphicsSceneMoveEvent();
}

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* QGraphicsSceneResizeEvent_NewQGraphicsSceneResizeEvent()
{
	return new QGraphicsSceneResizeEvent();
}

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();
}

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();
}

class MyQGraphicsSimpleTextItem: public QGraphicsSimpleTextItem
{
public:
	MyQGraphicsSimpleTextItem(QGraphicsItem *parent) : QGraphicsSimpleTextItem(parent) {};
	MyQGraphicsSimpleTextItem(const QString &text, QGraphicsItem *parent) : QGraphicsSimpleTextItem(text, parent) {};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsSimpleTextItem_BoundingRect(const_cast<MyQGraphicsSimpleTextItem*>(this))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsSimpleTextItem_Contains(const_cast<MyQGraphicsSimpleTextItem*>(this), const_cast<QPointF*>(&point)) != 0; };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsSimpleTextItem_IsObscuredBy(const_cast<MyQGraphicsSimpleTextItem*>(this), const_cast<QGraphicsItem*>(item)) != 0; };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsSimpleTextItem_OpaqueArea(const_cast<MyQGraphicsSimpleTextItem*>(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*>(callbackQGraphicsSimpleTextItem_Shape(const_cast<MyQGraphicsSimpleTextItem*>(this))); };
	int type() const { return callbackQGraphicsSimpleTextItem_Type(const_cast<MyQGraphicsSimpleTextItem*>(this)); };
	void advance(int phase) { callbackQGraphicsSimpleTextItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsSimpleTextItem_CollidesWithItem(const_cast<MyQGraphicsSimpleTextItem*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsSimpleTextItem_CollidesWithPath(const_cast<MyQGraphicsSimpleTextItem*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsSimpleTextItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsSimpleTextItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsSimpleTextItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsSimpleTextItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsSimpleTextItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsSimpleTextItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsSimpleTextItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsSimpleTextItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsSimpleTextItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsSimpleTextItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsSimpleTextItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsSimpleTextItem_InputMethodQuery(const_cast<MyQGraphicsSimpleTextItem*>(this), query)); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsSimpleTextItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsSimpleTextItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsSimpleTextItem_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsSimpleTextItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsSimpleTextItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsSimpleTextItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsSimpleTextItem_MouseReleaseEvent(this, event); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsSimpleTextItem_SceneEvent(this, event) != 0; };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsSimpleTextItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsSimpleTextItem_WheelEvent(this, event); };
};

void* QGraphicsSimpleTextItem_NewQGraphicsSimpleTextItem(void* parent)
{
	return new MyQGraphicsSimpleTextItem(static_cast<QGraphicsItem*>(parent));
}

void* QGraphicsSimpleTextItem_NewQGraphicsSimpleTextItem2(char* text, void* parent)
{
	return new MyQGraphicsSimpleTextItem(QString(text), 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()); });
}

char QGraphicsSimpleTextItem_Contains(void* ptr, void* point)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsSimpleTextItem_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::contains(*static_cast<QPointF*>(point));
}

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

char QGraphicsSimpleTextItem_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsSimpleTextItem_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

void* QGraphicsSimpleTextItem_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsSimpleTextItem*>(ptr)->opaqueArea());
}

void* QGraphicsSimpleTextItem_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::opaqueArea());
}

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, char* text)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->setText(QString(text));
}

void* QGraphicsSimpleTextItem_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsSimpleTextItem*>(ptr)->shape());
}

void* QGraphicsSimpleTextItem_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::shape());
}

char* QGraphicsSimpleTextItem_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QGraphicsSimpleTextItem*>(ptr)->text().toUtf8().prepend("WHITESPACE").constData()+10);
}

int QGraphicsSimpleTextItem_Type(void* ptr)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->type();
}

int QGraphicsSimpleTextItem_TypeDefault(void* ptr)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::type();
}

void QGraphicsSimpleTextItem_DestroyQGraphicsSimpleTextItem(void* ptr)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->~QGraphicsSimpleTextItem();
}

void QGraphicsSimpleTextItem_Advance(void* ptr, int phase)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->advance(phase);
}

void QGraphicsSimpleTextItem_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::advance(phase);
}

char QGraphicsSimpleTextItem_CollidesWithItem(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsSimpleTextItem_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsSimpleTextItem_CollidesWithPath(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsSimpleTextItem_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

void QGraphicsSimpleTextItem_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsSimpleTextItem_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsSimpleTextItem_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsSimpleTextItem_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsSimpleTextItem_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsSimpleTextItem_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsSimpleTextItem_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsSimpleTextItem_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsSimpleTextItem_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsSimpleTextItem_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsSimpleTextItem_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsSimpleTextItem_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsSimpleTextItem_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsSimpleTextItem_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsSimpleTextItem_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsSimpleTextItem_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsSimpleTextItem_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsSimpleTextItem_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsSimpleTextItem_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsSimpleTextItem_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsSimpleTextItem_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsSimpleTextItem_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsSimpleTextItem_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsSimpleTextItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsSimpleTextItem_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsSimpleTextItem_ItemChange(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsSimpleTextItem*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsSimpleTextItem_ItemChangeDefault(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void QGraphicsSimpleTextItem_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsSimpleTextItem_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsSimpleTextItem_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsSimpleTextItem_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsSimpleTextItem_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsSimpleTextItem_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsSimpleTextItem_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsSimpleTextItem_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsSimpleTextItem_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsSimpleTextItem_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsSimpleTextItem_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsSimpleTextItem_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

char QGraphicsSimpleTextItem_SceneEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsSimpleTextItem_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsSimpleTextItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsSimpleTextItem_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

void QGraphicsSimpleTextItem_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsSimpleTextItem_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

class MyQGraphicsTextItem: public QGraphicsTextItem
{
public:
	MyQGraphicsTextItem(QGraphicsItem *parent) : QGraphicsTextItem(parent) {};
	MyQGraphicsTextItem(const QString &text, QGraphicsItem *parent) : QGraphicsTextItem(text, parent) {};
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsTextItem_BoundingRect(const_cast<MyQGraphicsTextItem*>(this))); };
	bool contains(const QPointF & point) const { return callbackQGraphicsTextItem_Contains(const_cast<MyQGraphicsTextItem*>(this), const_cast<QPointF*>(&point)) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsTextItem_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsTextItem_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsTextItem_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsTextItem_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsTextItem_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsTextItem_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsTextItem_FocusOutEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsTextItem_HoverEnterEvent(this, event); };
	void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsTextItem_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsTextItem_HoverMoveEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsTextItem_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsTextItem_InputMethodQuery(const_cast<MyQGraphicsTextItem*>(this), query)); };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsTextItem_IsObscuredBy(const_cast<MyQGraphicsTextItem*>(this), const_cast<QGraphicsItem*>(item)) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsTextItem_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsTextItem_KeyReleaseEvent(this, event); };
	void Signal_LinkActivated(const QString & link) { callbackQGraphicsTextItem_LinkActivated(this, const_cast<char*>(link.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_LinkHovered(const QString & link) { callbackQGraphicsTextItem_LinkHovered(this, const_cast<char*>(link.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsTextItem_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsTextItem_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsTextItem_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsTextItem_MouseReleaseEvent(this, event); };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsTextItem_OpaqueArea(const_cast<MyQGraphicsTextItem*>(this))); };
	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsTextItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
	bool sceneEvent(QEvent * event) { return callbackQGraphicsTextItem_SceneEvent(this, event) != 0; };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsTextItem_Shape(const_cast<MyQGraphicsTextItem*>(this))); };
	int type() const { return callbackQGraphicsTextItem_Type(const_cast<MyQGraphicsTextItem*>(this)); };
	void updateMicroFocus() { callbackQGraphicsTextItem_UpdateMicroFocus(this); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsTextItem_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQGraphicsTextItem_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsTextItem_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsTextItem_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsTextItem_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsTextItem_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsTextItem_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsTextItem_MetaObject(const_cast<MyQGraphicsTextItem*>(this))); };
	void advance(int phase) { callbackQGraphicsTextItem_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsTextItem_CollidesWithItem(const_cast<MyQGraphicsTextItem*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsTextItem_CollidesWithPath(const_cast<MyQGraphicsTextItem*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsTextItem_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsTextItem_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsTextItem_WheelEvent(this, event); };
};

char QGraphicsTextItem_OpenExternalLinks(void* ptr)
{
	return static_cast<QGraphicsTextItem*>(ptr)->openExternalLinks();
}

void QGraphicsTextItem_SetOpenExternalLinks(void* ptr, char open)
{
	static_cast<QGraphicsTextItem*>(ptr)->setOpenExternalLinks(open != 0);
}

void QGraphicsTextItem_SetTextCursor(void* ptr, void* cursor)
{
	static_cast<QGraphicsTextItem*>(ptr)->setTextCursor(*static_cast<QTextCursor*>(cursor));
}

void* QGraphicsTextItem_TextCursor(void* ptr)
{
	return new QTextCursor(static_cast<QGraphicsTextItem*>(ptr)->textCursor());
}

void* QGraphicsTextItem_NewQGraphicsTextItem(void* parent)
{
	return new MyQGraphicsTextItem(static_cast<QGraphicsItem*>(parent));
}

void* QGraphicsTextItem_NewQGraphicsTextItem2(char* text, void* parent)
{
	return new MyQGraphicsTextItem(QString(text), 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()); });
}

char QGraphicsTextItem_Contains(void* ptr, void* point)
{
	return static_cast<QGraphicsTextItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsTextItem_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::contains(*static_cast<QPointF*>(point));
}

void QGraphicsTextItem_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsTextItem_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

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_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsTextItem_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsTextItem_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsTextItem_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsTextItem_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsTextItem_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsTextItem_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsTextItem_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsTextItem_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsTextItem_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsTextItem_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsTextItem_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::focusOutEvent(static_cast<QFocusEvent*>(event));
}

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

void QGraphicsTextItem_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsTextItem_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsTextItem_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsTextItem_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsTextItem_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsTextItem_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsTextItem_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsTextItem_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsTextItem_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsTextItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsTextItem_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

char QGraphicsTextItem_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QGraphicsTextItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsTextItem_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

void QGraphicsTextItem_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsTextItem_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsTextItem_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsTextItem_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsTextItem_ConnectLinkActivated(void* ptr)
{
	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));
}

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, char* link)
{
	static_cast<QGraphicsTextItem*>(ptr)->linkActivated(QString(link));
}

void QGraphicsTextItem_ConnectLinkHovered(void* ptr)
{
	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));
}

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, char* link)
{
	static_cast<QGraphicsTextItem*>(ptr)->linkHovered(QString(link));
}

void QGraphicsTextItem_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsTextItem_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsTextItem_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsTextItem_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsTextItem_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsTextItem_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsTextItem_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsTextItem_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void* QGraphicsTextItem_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsTextItem*>(ptr)->opaqueArea());
}

void* QGraphicsTextItem_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::opaqueArea());
}

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));
}

char QGraphicsTextItem_SceneEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsTextItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsTextItem_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::sceneEvent(static_cast<QEvent*>(event));
}

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, char* text)
{
	static_cast<QGraphicsTextItem*>(ptr)->setHtml(QString(text));
}

void QGraphicsTextItem_SetPlainText(void* ptr, char* text)
{
	static_cast<QGraphicsTextItem*>(ptr)->setPlainText(QString(text));
}

void QGraphicsTextItem_SetTabChangesFocus(void* ptr, char b)
{
	static_cast<QGraphicsTextItem*>(ptr)->setTabChangesFocus(b != 0);
}

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);
}

void* QGraphicsTextItem_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsTextItem*>(ptr)->shape());
}

void* QGraphicsTextItem_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::shape());
}

char QGraphicsTextItem_TabChangesFocus(void* ptr)
{
	return static_cast<QGraphicsTextItem*>(ptr)->tabChangesFocus();
}

long long QGraphicsTextItem_TextInteractionFlags(void* ptr)
{
	return static_cast<QGraphicsTextItem*>(ptr)->textInteractionFlags();
}

double QGraphicsTextItem_TextWidth(void* ptr)
{
	return static_cast<QGraphicsTextItem*>(ptr)->textWidth();
}

char* QGraphicsTextItem_ToHtml(void* ptr)
{
	return const_cast<char*>(static_cast<QGraphicsTextItem*>(ptr)->toHtml().toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QGraphicsTextItem_ToPlainText(void* ptr)
{
	return const_cast<char*>(static_cast<QGraphicsTextItem*>(ptr)->toPlainText().toUtf8().prepend("WHITESPACE").constData()+10);
}

int QGraphicsTextItem_Type(void* ptr)
{
	return static_cast<QGraphicsTextItem*>(ptr)->type();
}

int QGraphicsTextItem_TypeDefault(void* ptr)
{
	return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::type();
}

void QGraphicsTextItem_DestroyQGraphicsTextItem(void* ptr)
{
	static_cast<QGraphicsTextItem*>(ptr)->~QGraphicsTextItem();
}

void QGraphicsTextItem_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsTextItem*>(ptr), "updateMicroFocus");
}

void QGraphicsTextItem_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::updateMicroFocus();
}

void QGraphicsTextItem_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsTextItem_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsTextItem_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsTextItem*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsTextItem_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsTextItem_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsTextItem*>(ptr), "deleteLater");
}

void QGraphicsTextItem_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::deleteLater();
}

void QGraphicsTextItem_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsTextItem*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGraphicsTextItem_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsTextItem*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsTextItem_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsTextItem_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsTextItem*>(ptr)->metaObject());
}

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

void QGraphicsTextItem_Advance(void* ptr, int phase)
{
	static_cast<QGraphicsTextItem*>(ptr)->advance(phase);
}

void QGraphicsTextItem_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::advance(phase);
}

char QGraphicsTextItem_CollidesWithItem(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsTextItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsTextItem_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsTextItem_CollidesWithPath(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsTextItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsTextItem_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

void* QGraphicsTextItem_ItemChange(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsTextItem*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsTextItem_ItemChangeDefault(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

char QGraphicsTextItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsTextItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsTextItem_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

void QGraphicsTextItem_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsTextItem_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

class MyQGraphicsTransform: public QGraphicsTransform
{
public:
	MyQGraphicsTransform(QObject *parent) : QGraphicsTransform(parent) {};
	void applyTo(QMatrix4x4 * matrix) const { callbackQGraphicsTransform_ApplyTo(const_cast<MyQGraphicsTransform*>(this), matrix); };
	void update() { callbackQGraphicsTransform_Update(this); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsTransform_TimerEvent(this, event); };
	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 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<MyQGraphicsTransform*>(this))); };
};

void* QGraphicsTransform_NewQGraphicsTransform(void* parent)
{
	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_DestroyQGraphicsTransform(void* ptr)
{
	static_cast<QGraphicsTransform*>(ptr)->~QGraphicsTransform();
}

void QGraphicsTransform_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTransform*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsTransform_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTransform*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsTransform_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsTransform*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsTransform_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsTransform*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsTransform_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsTransform*>(ptr), "deleteLater");
}

void QGraphicsTransform_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::deleteLater();
}

void QGraphicsTransform_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsTransform*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGraphicsTransform_Event(void* ptr, void* e)
{
	return static_cast<QGraphicsTransform*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QGraphicsTransform_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsTransform*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsTransform_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsTransform_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsTransform*>(ptr)->metaObject());
}

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

class MyQGraphicsView: public QGraphicsView
{
public:
	MyQGraphicsView(QGraphicsScene *scene, QWidget *parent) : QGraphicsView(scene, parent) {};
	MyQGraphicsView(QWidget *parent) : QGraphicsView(parent) {};
	void contextMenuEvent(QContextMenuEvent * event) { callbackQGraphicsView_ContextMenuEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQGraphicsView_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQGraphicsView_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQGraphicsView_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) { callbackQGraphicsView_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQGraphicsView_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQGraphicsView_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsView_FocusOutEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsView_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsView_InputMethodQuery(const_cast<MyQGraphicsView*>(this), query)); };
	void invalidateScene(const QRectF & rect, QGraphicsScene::SceneLayers layers) { callbackQGraphicsView_InvalidateScene(this, const_cast<QRectF*>(&rect), layers); };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsView_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsView_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQGraphicsView_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQGraphicsView_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQGraphicsView_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQGraphicsView_MouseReleaseEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQGraphicsView_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQGraphicsView_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) { callbackQGraphicsView_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * widget) { callbackQGraphicsView_SetupViewport(this, widget); };
	void showEvent(QShowEvent * event) { callbackQGraphicsView_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQGraphicsView_SizeHint(const_cast<MyQGraphicsView*>(this))); };
	void updateSceneRect(const QRectF & rect) { callbackQGraphicsView_UpdateSceneRect(this, const_cast<QRectF*>(&rect)); };
	bool viewportEvent(QEvent * event) { return callbackQGraphicsView_ViewportEvent(this, event) != 0; };
	void wheelEvent(QWheelEvent * event) { callbackQGraphicsView_WheelEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQGraphicsView_MinimumSizeHint(const_cast<MyQGraphicsView*>(this))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQGraphicsView_ViewportSizeHint(const_cast<MyQGraphicsView*>(this))); };
	void changeEvent(QEvent * ev) { callbackQGraphicsView_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQGraphicsView_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQGraphicsView_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQGraphicsView_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQGraphicsView_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQGraphicsView_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQGraphicsView_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQGraphicsView_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQGraphicsView_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQGraphicsView_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQGraphicsView_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQGraphicsView_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQGraphicsView_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQGraphicsView_HasHeightForWidth(const_cast<MyQGraphicsView*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQGraphicsView_HeightForWidth(const_cast<MyQGraphicsView*>(this), w); };
	void hide() { callbackQGraphicsView_Hide(this); };
	void lower() { callbackQGraphicsView_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQGraphicsView_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQGraphicsView_Raise(this); };
	void repaint() { callbackQGraphicsView_Repaint(this); };
	void setDisabled(bool disable) { callbackQGraphicsView_SetDisabled(this, disable); };
	void setFocus() { callbackQGraphicsView_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQGraphicsView_SetHidden(this, hidden); };
	void show() { callbackQGraphicsView_Show(this); };
	void showFullScreen() { callbackQGraphicsView_ShowFullScreen(this); };
	void showMaximized() { callbackQGraphicsView_ShowMaximized(this); };
	void showMinimized() { callbackQGraphicsView_ShowMinimized(this); };
	void showNormal() { callbackQGraphicsView_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQGraphicsView_TabletEvent(this, event); };
	void update() { callbackQGraphicsView_Update(this); };
	void updateMicroFocus() { callbackQGraphicsView_UpdateMicroFocus(this); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsView_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQGraphicsView_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsView_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsView_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsView_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsView_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsView_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsView_MetaObject(const_cast<MyQGraphicsView*>(this))); };
};

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();
}

long long QGraphicsView_DragMode(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->dragMode();
}

void* QGraphicsView_ForegroundBrush(void* ptr)
{
	return new QBrush(static_cast<QGraphicsView*>(ptr)->foregroundBrush());
}

char QGraphicsView_IsInteractive(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->isInteractive();
}

long long QGraphicsView_OptimizationFlags(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->optimizationFlags();
}

long long QGraphicsView_RenderHints(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->renderHints();
}

long long QGraphicsView_ResizeAnchor(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->resizeAnchor();
}

long long QGraphicsView_RubberBandSelectionMode(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->rubberBandSelectionMode();
}

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_SetOptimizationFlags(void* ptr, long long flags)
{
	static_cast<QGraphicsView*>(ptr)->setOptimizationFlags(static_cast<QGraphicsView::OptimizationFlag>(flags));
}

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_SetSceneRect(void* ptr, void* rect)
{
	static_cast<QGraphicsView*>(ptr)->setSceneRect(*static_cast<QRectF*>(rect));
}

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));
}

long long QGraphicsView_TransformationAnchor(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->transformationAnchor();
}

long long QGraphicsView_ViewportUpdateMode(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->viewportUpdateMode();
}

void* QGraphicsView_NewQGraphicsView2(void* scene, void* parent)
{
	return new MyQGraphicsView(static_cast<QGraphicsScene*>(scene), static_cast<QWidget*>(parent));
}

void* QGraphicsView_NewQGraphicsView(void* parent)
{
	return new MyQGraphicsView(static_cast<QWidget*>(parent));
}

void QGraphicsView_CenterOn3(void* ptr, void* item)
{
	static_cast<QGraphicsView*>(ptr)->centerOn(static_cast<QGraphicsItem*>(item));
}

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_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QGraphicsView_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QGraphicsView_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QGraphicsView_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QGraphicsView_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QGraphicsView_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QGraphicsView_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QGraphicsView_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

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_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QGraphicsView_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::dropEvent(static_cast<QDropEvent*>(event));
}

void QGraphicsView_EnsureVisible3(void* ptr, void* item, int xmargin, int ymargin)
{
	static_cast<QGraphicsView*>(ptr)->ensureVisible(static_cast<QGraphicsItem*>(item), xmargin, ymargin);
}

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);
}

char QGraphicsView_Event(void* ptr, void* event)
{
	return static_cast<QGraphicsView*>(ptr)->event(static_cast<QEvent*>(event));
}

void QGraphicsView_FitInView3(void* ptr, void* item, long long aspectRatioMode)
{
	static_cast<QGraphicsView*>(ptr)->fitInView(static_cast<QGraphicsItem*>(item), static_cast<Qt::AspectRatioMode>(aspectRatioMode));
}

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_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsView_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QGraphicsView_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QGraphicsView*>(ptr)->focusNextPrevChild(next != 0);
}

char QGraphicsView_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QGraphicsView*>(ptr)->QGraphicsView::focusNextPrevChild(next != 0);
}

void QGraphicsView_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsView_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsView_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsView_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsView_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsView_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsView*>(ptr)->QGraphicsView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QGraphicsView_InvalidateScene(void* ptr, void* rect, long long layers)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "invalidateScene", Q_ARG(QRectF, *static_cast<QRectF*>(rect)), Q_ARG(QGraphicsScene::SceneLayer, static_cast<QGraphicsScene::SceneLayer>(layers)));
}

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);
}

void QGraphicsView_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsView_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsView_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsView_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void* QGraphicsView_MapFromScene4(void* ptr, void* path)
{
	return new QPainterPath(static_cast<QGraphicsView*>(ptr)->mapFromScene(*static_cast<QPainterPath*>(path)));
}

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_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_MapFromScene3(void* ptr, void* polygon)
{
	return new QPolygon(static_cast<QGraphicsView*>(ptr)->mapFromScene(*static_cast<QPolygonF*>(polygon)));
}

void* QGraphicsView_MapFromScene2(void* ptr, void* rect)
{
	return new QPolygon(static_cast<QGraphicsView*>(ptr)->mapFromScene(*static_cast<QRectF*>(rect)));
}

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_MapToScene4(void* ptr, void* path)
{
	return new QPainterPath(static_cast<QGraphicsView*>(ptr)->mapToScene(*static_cast<QPainterPath*>(path)));
}

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_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_MapToScene3(void* ptr, void* polygon)
{
	return new QPolygonF(static_cast<QGraphicsView*>(ptr)->mapToScene(*static_cast<QPolygon*>(polygon)));
}

void* QGraphicsView_MapToScene2(void* ptr, void* rect)
{
	return new QPolygonF(static_cast<QGraphicsView*>(ptr)->mapToScene(*static_cast<QRect*>(rect)));
}

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_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QGraphicsView_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QGraphicsView_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QGraphicsView_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QGraphicsView_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QGraphicsView_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QGraphicsView_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QGraphicsView_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QGraphicsView_PaintEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QGraphicsView_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::paintEvent(static_cast<QPaintEvent*>(event));
}

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));
}

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();
}

void QGraphicsView_ResizeEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QGraphicsView_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QGraphicsView_Rotate(void* ptr, double angle)
{
	static_cast<QGraphicsView*>(ptr)->rotate(angle);
}

void QGraphicsView_ConnectRubberBandChanged(void* ptr)
{
	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));
}

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()); });
}

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_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QGraphicsView*>(ptr)->scrollContentsBy(dx, dy);
}

void QGraphicsView_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::scrollContentsBy(dx, dy);
}

void QGraphicsView_SetOptimizationFlag(void* ptr, long long flag, char enabled)
{
	static_cast<QGraphicsView*>(ptr)->setOptimizationFlag(static_cast<QGraphicsView::OptimizationFlag>(flag), enabled != 0);
}

void QGraphicsView_SetRenderHint(void* ptr, long long hint, char enabled)
{
	static_cast<QGraphicsView*>(ptr)->setRenderHint(static_cast<QPainter::RenderHint>(hint), enabled != 0);
}

void QGraphicsView_SetScene(void* ptr, void* scene)
{
	static_cast<QGraphicsView*>(ptr)->setScene(static_cast<QGraphicsScene*>(scene));
}

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_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_ShowEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QGraphicsView_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::showEvent(static_cast<QShowEvent*>(event));
}

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

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

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

void QGraphicsView_Translate(void* ptr, double dx, double dy)
{
	static_cast<QGraphicsView*>(ptr)->translate(dx, dy);
}

void QGraphicsView_UpdateSceneRect(void* ptr, void* rect)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "updateSceneRect", Q_ARG(QRectF, *static_cast<QRectF*>(rect)));
}

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

char QGraphicsView_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsView*>(ptr)->QGraphicsView::viewportEvent(static_cast<QEvent*>(event));
}

void* QGraphicsView_ViewportTransform(void* ptr)
{
	return new QTransform(static_cast<QGraphicsView*>(ptr)->viewportTransform());
}

void QGraphicsView_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QGraphicsView_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QGraphicsView_DestroyQGraphicsView(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->~QGraphicsView();
}

void* QGraphicsView_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QGraphicsView*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QGraphicsView_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QGraphicsView*>(ptr)->QGraphicsView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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

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

void QGraphicsView_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QGraphicsView*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QGraphicsView_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::changeEvent(static_cast<QEvent*>(ev));
}

void QGraphicsView_ActionEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QGraphicsView_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::actionEvent(static_cast<QActionEvent*>(event));
}

void QGraphicsView_EnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QGraphicsView_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::enterEvent(static_cast<QEvent*>(event));
}

void QGraphicsView_HideEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QGraphicsView_HideEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::hideEvent(static_cast<QHideEvent*>(event));
}

void QGraphicsView_LeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QGraphicsView_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::leaveEvent(static_cast<QEvent*>(event));
}

void QGraphicsView_MoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QGraphicsView_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QGraphicsView_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QGraphicsView_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::setStyleSheet(QString(styleSheet));
}

void QGraphicsView_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QGraphicsView_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::setVisible(visible != 0);
}

void QGraphicsView_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QGraphicsView_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::setWindowModified(vbo != 0);
}

void QGraphicsView_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QGraphicsView_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::setWindowTitle(QString(vqs));
}

char QGraphicsView_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QGraphicsView_CloseDefault(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->QGraphicsView::close();
}

void QGraphicsView_CloseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QGraphicsView_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::closeEvent(static_cast<QCloseEvent*>(event));
}

char QGraphicsView_HasHeightForWidth(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->hasHeightForWidth();
}

char QGraphicsView_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QGraphicsView*>(ptr)->QGraphicsView::hasHeightForWidth();
}

int QGraphicsView_HeightForWidth(void* ptr, int w)
{
	return static_cast<QGraphicsView*>(ptr)->heightForWidth(w);
}

int QGraphicsView_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QGraphicsView*>(ptr)->QGraphicsView::heightForWidth(w);
}

void QGraphicsView_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "hide");
}

void QGraphicsView_HideDefault(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::hide();
}

void QGraphicsView_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "lower");
}

void QGraphicsView_LowerDefault(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::lower();
}

char QGraphicsView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QGraphicsView*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QGraphicsView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QGraphicsView*>(ptr)->QGraphicsView::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QGraphicsView_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "raise");
}

void QGraphicsView_RaiseDefault(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::raise();
}

void QGraphicsView_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "repaint");
}

void QGraphicsView_RepaintDefault(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::repaint();
}

void QGraphicsView_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QGraphicsView_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::setDisabled(disable != 0);
}

void QGraphicsView_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "setFocus");
}

void QGraphicsView_SetFocus2Default(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::setFocus();
}

void QGraphicsView_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QGraphicsView_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::setHidden(hidden != 0);
}

void QGraphicsView_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "show");
}

void QGraphicsView_ShowDefault(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::show();
}

void QGraphicsView_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "showFullScreen");
}

void QGraphicsView_ShowFullScreenDefault(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::showFullScreen();
}

void QGraphicsView_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "showMaximized");
}

void QGraphicsView_ShowMaximizedDefault(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::showMaximized();
}

void QGraphicsView_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "showMinimized");
}

void QGraphicsView_ShowMinimizedDefault(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::showMinimized();
}

void QGraphicsView_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "showNormal");
}

void QGraphicsView_ShowNormalDefault(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::showNormal();
}

void QGraphicsView_TabletEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QGraphicsView_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QGraphicsView_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "update");
}

void QGraphicsView_UpdateDefault(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::update();
}

void QGraphicsView_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "updateMicroFocus");
}

void QGraphicsView_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::updateMicroFocus();
}

void QGraphicsView_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsView_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsView_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsView*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsView_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsView*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsView_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "deleteLater");
}

void QGraphicsView_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsView*>(ptr)->QGraphicsView::deleteLater();
}

void QGraphicsView_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsView*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGraphicsView_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsView_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsView*>(ptr)->QGraphicsView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsView_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsView*>(ptr)->metaObject());
}

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

class MyQGraphicsWidget: public QGraphicsWidget
{
public:
	MyQGraphicsWidget(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent, wFlags) {};
	void setGeometry(const QRectF & rect) { callbackQGraphicsWidget_SetGeometry(this, const_cast<QRectF*>(&rect)); };
	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsWidget_BoundingRect(const_cast<MyQGraphicsWidget*>(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 focusInEvent(QFocusEvent * event) { callbackQGraphicsWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQGraphicsWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQGraphicsWidget_FocusOutEvent(this, event); };
	void Signal_GeometryChanged() { callbackQGraphicsWidget_GeometryChanged(this); };
	void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsWidget_GetContentsMargins(const_cast<MyQGraphicsWidget*>(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) { callbackQGraphicsWidget_HoverLeaveEvent(this, event); };
	void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsWidget_HoverMoveEvent(this, event); };
	void initStyleOption(QStyleOption * option) const { callbackQGraphicsWidget_InitStyleOption(const_cast<MyQGraphicsWidget*>(this), option); };
	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsWidget_ItemChange(this, change, const_cast<QVariant*>(&value))); };
	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 callbackQGraphicsWidget_SceneEvent(this, event) != 0; };
	QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsWidget_Shape(const_cast<MyQGraphicsWidget*>(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<MyQGraphicsWidget*>(this), which, const_cast<QSizeF*>(&constraint))); };
	int type() const { return callbackQGraphicsWidget_Type(const_cast<MyQGraphicsWidget*>(this)); };
	void ungrabKeyboardEvent(QEvent * event) { callbackQGraphicsWidget_UngrabKeyboardEvent(this, event); };
	void ungrabMouseEvent(QEvent * event) { callbackQGraphicsWidget_UngrabMouseEvent(this, event); };
	void updateGeometry() { callbackQGraphicsWidget_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<MyQGraphicsWidget*>(this), const_cast<QPointF*>(&pos))); };
	void updateMicroFocus() { callbackQGraphicsWidget_UpdateMicroFocus(this); };
	void timerEvent(QTimerEvent * event) { callbackQGraphicsWidget_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQGraphicsWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGraphicsWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGraphicsWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQGraphicsWidget_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsWidget_MetaObject(const_cast<MyQGraphicsWidget*>(this))); };
	void advance(int phase) { callbackQGraphicsWidget_Advance(this, phase); };
	bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsWidget_CollidesWithItem(const_cast<MyQGraphicsWidget*>(this), const_cast<QGraphicsItem*>(other), mode) != 0; };
	bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsWidget_CollidesWithPath(const_cast<MyQGraphicsWidget*>(this), const_cast<QPainterPath*>(&path), mode) != 0; };
	bool contains(const QPointF & point) const { return callbackQGraphicsWidget_Contains(const_cast<MyQGraphicsWidget*>(this), const_cast<QPointF*>(&point)) != 0; };
	void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsWidget_ContextMenuEvent(this, event); };
	void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsWidget_DragMoveEvent(this, event); };
	void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsWidget_DropEvent(this, event); };
	void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsWidget_HoverEnterEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsWidget_InputMethodQuery(const_cast<MyQGraphicsWidget*>(this), query)); };
	bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsWidget_IsObscuredBy(const_cast<MyQGraphicsWidget*>(this), const_cast<QGraphicsItem*>(item)) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQGraphicsWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsWidget_KeyReleaseEvent(this, event); };
	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsWidget_MouseReleaseEvent(this, event); };
	QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsWidget_OpaqueArea(const_cast<MyQGraphicsWidget*>(this))); };
	bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsWidget_SceneEventFilter(this, watched, event) != 0; };
	void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsWidget_WheelEvent(this, event); };
};

char QGraphicsWidget_AutoFillBackground(void* ptr)
{
	return static_cast<QGraphicsWidget*>(ptr)->autoFillBackground();
}

long long QGraphicsWidget_FocusPolicy(void* ptr)
{
	return static_cast<QGraphicsWidget*>(ptr)->focusPolicy();
}

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

long long QGraphicsWidget_LayoutDirection(void* ptr)
{
	return static_cast<QGraphicsWidget*>(ptr)->layoutDirection();
}

void* QGraphicsWidget_Palette(void* ptr)
{
	return new QPalette(static_cast<QGraphicsWidget*>(ptr)->palette());
}

void QGraphicsWidget_Resize(void* ptr, void* size)
{
	static_cast<QGraphicsWidget*>(ptr)->resize(*static_cast<QSizeF*>(size));
}

void QGraphicsWidget_SetAutoFillBackground(void* ptr, char enabled)
{
	static_cast<QGraphicsWidget*>(ptr)->setAutoFillBackground(enabled != 0);
}

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_SetGeometry(void* ptr, void* rect)
{
	static_cast<QGraphicsWidget*>(ptr)->setGeometry(*static_cast<QRectF*>(rect));
}

void QGraphicsWidget_SetGeometryDefault(void* ptr, void* rect)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::setGeometry(*static_cast<QRectF*>(rect));
}

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_SetWindowFlags(void* ptr, long long wFlags)
{
	static_cast<QGraphicsWidget*>(ptr)->setWindowFlags(static_cast<Qt::WindowType>(wFlags));
}

void QGraphicsWidget_SetWindowTitle(void* ptr, char* title)
{
	static_cast<QGraphicsWidget*>(ptr)->setWindowTitle(QString(title));
}

void* QGraphicsWidget_Size(void* ptr)
{
	return ({ QSizeF tmpValue = static_cast<QGraphicsWidget*>(ptr)->size(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void QGraphicsWidget_UnsetLayoutDirection(void* ptr)
{
	static_cast<QGraphicsWidget*>(ptr)->unsetLayoutDirection();
}

long long QGraphicsWidget_WindowFlags(void* ptr)
{
	return static_cast<QGraphicsWidget*>(ptr)->windowFlags();
}

char* QGraphicsWidget_WindowTitle(void* ptr)
{
	return const_cast<char*>(static_cast<QGraphicsWidget*>(ptr)->windowTitle().toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QGraphicsWidget_NewQGraphicsWidget(void* parent, long long wFlags)
{
	return new MyQGraphicsWidget(static_cast<QGraphicsItem*>(parent), static_cast<Qt::WindowType>(wFlags));
}

void QGraphicsWidget_AddAction(void* ptr, void* action)
{
	static_cast<QGraphicsWidget*>(ptr)->addAction(static_cast<QAction*>(action));
}

void QGraphicsWidget_AdjustSize(void* ptr)
{
	static_cast<QGraphicsWidget*>(ptr)->adjustSize();
}

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)
{
	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)
{
	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;
}

void QGraphicsWidget_CloseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QGraphicsWidget_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::closeEvent(static_cast<QCloseEvent*>(event));
}

char QGraphicsWidget_Event(void* ptr, void* event)
{
	return static_cast<QGraphicsWidget*>(ptr)->event(static_cast<QEvent*>(event));
}

void QGraphicsWidget_FocusInEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsWidget_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QGraphicsWidget_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QGraphicsWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QGraphicsWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::focusNextPrevChild(next != 0);
}

void QGraphicsWidget_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGraphicsWidget_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void* QGraphicsWidget_FocusWidget(void* ptr)
{
	return static_cast<QGraphicsWidget*>(ptr)->focusWidget();
}

void QGraphicsWidget_ConnectGeometryChanged(void* ptr)
{
	QObject::connect(static_cast<QGraphicsWidget*>(ptr), static_cast<void (QGraphicsWidget::*)()>(&QGraphicsWidget::geometryChanged), static_cast<MyQGraphicsWidget*>(ptr), static_cast<void (MyQGraphicsWidget::*)()>(&MyQGraphicsWidget::Signal_GeometryChanged));
}

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_GetContentsMargins(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsWidget*>(ptr)->getContentsMargins(&left, &top, &right, &bottom);
}

void QGraphicsWidget_GetContentsMarginsDefault(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::getContentsMargins(&left, &top, &right, &bottom);
}

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)
{
	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)
{
	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)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::hideEvent(static_cast<QHideEvent*>(event));
}

void QGraphicsWidget_HoverLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsWidget_HoverLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::hoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsWidget_HoverMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsWidget_HoverMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::hoverMoveEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsWidget_InitStyleOption(void* ptr, void* option)
{
	static_cast<QGraphicsWidget*>(ptr)->initStyleOption(static_cast<QStyleOption*>(option));
}

void QGraphicsWidget_InitStyleOptionDefault(void* ptr, void* option)
{
	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));
}

char QGraphicsWidget_IsActiveWindow(void* ptr)
{
	return static_cast<QGraphicsWidget*>(ptr)->isActiveWindow();
}

void* QGraphicsWidget_ItemChange(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsWidget*>(ptr)->itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsWidget_ItemChangeDefault(void* ptr, long long change, void* value)
{
	return new QVariant(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}

void* QGraphicsWidget_Layout(void* ptr)
{
	return static_cast<QGraphicsWidget*>(ptr)->layout();
}

void QGraphicsWidget_MoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->moveEvent(static_cast<QGraphicsSceneMoveEvent*>(event));
}

void QGraphicsWidget_MoveEventDefault(void* ptr, void* event)
{
	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)
{
	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)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::paintWindowFrame(static_cast<QPainter*>(painter), static_cast<QStyleOptionGraphicsItem*>(option), static_cast<QWidget*>(widget));
}

void QGraphicsWidget_PolishEvent(void* ptr)
{
	static_cast<QGraphicsWidget*>(ptr)->polishEvent();
}

void QGraphicsWidget_PolishEventDefault(void* ptr)
{
	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_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)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::resizeEvent(static_cast<QGraphicsSceneResizeEvent*>(event));
}

char QGraphicsWidget_SceneEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsWidget*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}

char QGraphicsWidget_SceneEventDefault(void* ptr, void* event)
{
	return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::sceneEvent(static_cast<QEvent*>(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_SetContentsMargins(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsWidget*>(ptr)->setContentsMargins(left, top, right, bottom);
}

void QGraphicsWidget_SetGeometry2(void* ptr, double x, double y, double w, double h)
{
	static_cast<QGraphicsWidget*>(ptr)->setGeometry(x, y, w, h);
}

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_SetWindowFrameMargins(void* ptr, double left, double top, double right, double bottom)
{
	static_cast<QGraphicsWidget*>(ptr)->setWindowFrameMargins(left, top, right, bottom);
}

void* QGraphicsWidget_Shape(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->shape());
}

void* QGraphicsWidget_ShapeDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::shape());
}

void QGraphicsWidget_ShowEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QGraphicsWidget_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::showEvent(static_cast<QShowEvent*>(event));
}

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)
{
	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));
}

int QGraphicsWidget_Type(void* ptr)
{
	return static_cast<QGraphicsWidget*>(ptr)->type();
}

int QGraphicsWidget_TypeDefault(void* ptr)
{
	return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::type();
}

void QGraphicsWidget_UngrabKeyboardEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->ungrabKeyboardEvent(static_cast<QEvent*>(event));
}

void QGraphicsWidget_UngrabKeyboardEventDefault(void* ptr, void* event)
{
	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)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::ungrabMouseEvent(static_cast<QEvent*>(event));
}

void QGraphicsWidget_UnsetWindowFrameMargins(void* ptr)
{
	static_cast<QGraphicsWidget*>(ptr)->unsetWindowFrameMargins();
}

void QGraphicsWidget_UpdateGeometry(void* ptr)
{
	static_cast<QGraphicsWidget*>(ptr)->updateGeometry();
}

void QGraphicsWidget_UpdateGeometryDefault(void* ptr)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::updateGeometry();
}

char QGraphicsWidget_WindowFrameEvent(void* ptr, void* event)
{
	return static_cast<QGraphicsWidget*>(ptr)->windowFrameEvent(static_cast<QEvent*>(event));
}

char QGraphicsWidget_WindowFrameEventDefault(void* ptr, void* event)
{
	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)
{
	return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::windowFrameSectionAt(*static_cast<QPointF*>(pos));
}

long long QGraphicsWidget_WindowType(void* ptr)
{
	return static_cast<QGraphicsWidget*>(ptr)->windowType();
}

void QGraphicsWidget_DestroyQGraphicsWidget(void* ptr)
{
	static_cast<QGraphicsWidget*>(ptr)->~QGraphicsWidget();
}

void QGraphicsWidget_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsWidget*>(ptr), "updateMicroFocus");
}

void QGraphicsWidget_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::updateMicroFocus();
}

void QGraphicsWidget_TimerEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGraphicsWidget_ChildEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QGraphicsWidget_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGraphicsWidget_CustomEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGraphicsWidget_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGraphicsWidget*>(ptr), "deleteLater");
}

void QGraphicsWidget_DeleteLaterDefault(void* ptr)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::deleteLater();
}

void QGraphicsWidget_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGraphicsWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGraphicsWidget_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsWidget_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGraphicsWidget_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGraphicsWidget*>(ptr)->metaObject());
}

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

void QGraphicsWidget_Advance(void* ptr, int phase)
{
	static_cast<QGraphicsWidget*>(ptr)->advance(phase);
}

void QGraphicsWidget_AdvanceDefault(void* ptr, int phase)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::advance(phase);
}

char QGraphicsWidget_CollidesWithItem(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsWidget*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsWidget_CollidesWithItemDefault(void* ptr, void* other, long long mode)
{
	return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsWidget_CollidesWithPath(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsWidget*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsWidget_CollidesWithPathDefault(void* ptr, void* path, long long mode)
{
	return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}

char QGraphicsWidget_Contains(void* ptr, void* point)
{
	return static_cast<QGraphicsWidget*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QGraphicsWidget_ContainsDefault(void* ptr, void* point)
{
	return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::contains(*static_cast<QPointF*>(point));
}

void QGraphicsWidget_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsWidget_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(event));
}

void QGraphicsWidget_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsWidget_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsWidget_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsWidget_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsWidget_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsWidget_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsWidget_DropEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsWidget_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::dropEvent(static_cast<QGraphicsSceneDragDropEvent*>(event));
}

void QGraphicsWidget_HoverEnterEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsWidget_HoverEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::hoverEnterEvent(static_cast<QGraphicsSceneHoverEvent*>(event));
}

void QGraphicsWidget_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGraphicsWidget_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGraphicsWidget_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGraphicsWidget_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

char QGraphicsWidget_IsObscuredBy(void* ptr, void* item)
{
	return static_cast<QGraphicsWidget*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}

char QGraphicsWidget_IsObscuredByDefault(void* ptr, void* item)
{
	return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::isObscuredBy(static_cast<QGraphicsItem*>(item));
}

void QGraphicsWidget_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsWidget_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsWidget_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsWidget_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGraphicsWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsWidget_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsWidget_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsWidget_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsWidget_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsWidget_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void QGraphicsWidget_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event));
}

void* QGraphicsWidget_OpaqueArea(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->opaqueArea());
}

void* QGraphicsWidget_OpaqueAreaDefault(void* ptr)
{
	return new QPainterPath(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::opaqueArea());
}

char QGraphicsWidget_SceneEventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsWidget*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

char QGraphicsWidget_SceneEventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}

void QGraphicsWidget_WheelEvent(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

void QGraphicsWidget_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::wheelEvent(static_cast<QGraphicsSceneWheelEvent*>(event));
}

class MyQGridLayout: public QGridLayout
{
public:
	MyQGridLayout() : QGridLayout() {};
	MyQGridLayout(QWidget *parent) : QGridLayout(parent) {};
	void addItem(QLayoutItem * item) { callbackQGridLayout_AddItem2(this, item); };
	int count() const { return callbackQGridLayout_Count(const_cast<MyQGridLayout*>(this)); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQGridLayout_ExpandingDirections(const_cast<MyQGridLayout*>(this))); };
	bool hasHeightForWidth() const { return callbackQGridLayout_HasHeightForWidth(const_cast<MyQGridLayout*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQGridLayout_HeightForWidth(const_cast<MyQGridLayout*>(this), w); };
	void invalidate() { callbackQGridLayout_Invalidate(this); };
	QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQGridLayout_ItemAt(const_cast<MyQGridLayout*>(this), index)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQGridLayout_MaximumSize(const_cast<MyQGridLayout*>(this))); };
	int minimumHeightForWidth(int w) const { return callbackQGridLayout_MinimumHeightForWidth(const_cast<MyQGridLayout*>(this), w); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQGridLayout_MinimumSize(const_cast<MyQGridLayout*>(this))); };
	void setGeometry(const QRect & rect) { callbackQGridLayout_SetGeometry(this, const_cast<QRect*>(&rect)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQGridLayout_SizeHint(const_cast<MyQGridLayout*>(this))); };
	QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQGridLayout_TakeAt(this, index)); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQGridLayout_ControlTypes(const_cast<MyQGridLayout*>(this))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQGridLayout_Geometry(const_cast<MyQGridLayout*>(this))); };
	int indexOf(QWidget * widget) const { return callbackQGridLayout_IndexOf(const_cast<MyQGridLayout*>(this), widget); };
	bool isEmpty() const { return callbackQGridLayout_IsEmpty(const_cast<MyQGridLayout*>(this)) != 0; };
	QLayout * layout() { return static_cast<QLayout*>(callbackQGridLayout_Layout(this)); };
	void timerEvent(QTimerEvent * event) { callbackQGridLayout_TimerEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGridLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGridLayout_CustomEvent(this, event); };
	void deleteLater() { callbackQGridLayout_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGridLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQGridLayout_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGridLayout_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGridLayout_MetaObject(const_cast<MyQGridLayout*>(this))); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQGridLayout_SpacerItem(this)); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQGridLayout_Widget(this)); };
};

int QGridLayout_HorizontalSpacing(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->horizontalSpacing();
}

void QGridLayout_SetHorizontalSpacing(void* ptr, int spacing)
{
	static_cast<QGridLayout*>(ptr)->setHorizontalSpacing(spacing);
}

void QGridLayout_SetVerticalSpacing(void* ptr, int spacing)
{
	static_cast<QGridLayout*>(ptr)->setVerticalSpacing(spacing);
}

int QGridLayout_VerticalSpacing(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->verticalSpacing();
}

void* QGridLayout_NewQGridLayout2()
{
	return new MyQGridLayout();
}

void* QGridLayout_NewQGridLayout(void* parent)
{
	return new MyQGridLayout(static_cast<QWidget*>(parent));
}

void QGridLayout_AddItem(void* ptr, void* item, int row, int column, int rowSpan, int columnSpan, long long alignment)
{
	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)
{
	static_cast<QGridLayout*>(ptr)->addItem(static_cast<QLayoutItem*>(item));
}

void QGridLayout_AddItem2Default(void* ptr, void* item)
{
	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_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_AddWidget(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_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();
}

long long QGridLayout_ExpandingDirections(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->expandingDirections();
}

long long QGridLayout_ExpandingDirectionsDefault(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->QGridLayout::expandingDirections();
}

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);
}

char QGridLayout_HasHeightForWidth(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->hasHeightForWidth();
}

char QGridLayout_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->QGridLayout::hasHeightForWidth();
}

int QGridLayout_HeightForWidth(void* ptr, int w)
{
	return static_cast<QGridLayout*>(ptr)->heightForWidth(w);
}

int QGridLayout_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QGridLayout*>(ptr)->QGridLayout::heightForWidth(w);
}

void QGridLayout_Invalidate(void* ptr)
{
	static_cast<QGridLayout*>(ptr)->invalidate();
}

void QGridLayout_InvalidateDefault(void* ptr)
{
	static_cast<QGridLayout*>(ptr)->QGridLayout::invalidate();
}

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);
}

void* QGridLayout_MaximumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QGridLayout*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QGridLayout_MaximumSizeDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QGridLayout*>(ptr)->QGridLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QGridLayout_MinimumHeightForWidth(void* ptr, int w)
{
	return static_cast<QGridLayout*>(ptr)->minimumHeightForWidth(w);
}

int QGridLayout_MinimumHeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QGridLayout*>(ptr)->QGridLayout::minimumHeightForWidth(w);
}

void* QGridLayout_MinimumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QGridLayout*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QGridLayout_MinimumSizeDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QGridLayout*>(ptr)->QGridLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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_SetGeometry(void* ptr, void* rect)
{
	static_cast<QGridLayout*>(ptr)->setGeometry(*static_cast<QRect*>(rect));
}

void QGridLayout_SetGeometryDefault(void* ptr, void* rect)
{
	static_cast<QGridLayout*>(ptr)->QGridLayout::setGeometry(*static_cast<QRect*>(rect));
}

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_SetSpacing(void* ptr, int spacing)
{
	static_cast<QGridLayout*>(ptr)->setSpacing(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()); });
}

int QGridLayout_Spacing(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->spacing();
}

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);
}

void QGridLayout_DestroyQGridLayout(void* ptr)
{
	static_cast<QGridLayout*>(ptr)->~QGridLayout();
}

long long QGridLayout_ControlTypes(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->controlTypes();
}

long long QGridLayout_ControlTypesDefault(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->QGridLayout::controlTypes();
}

void* QGridLayout_Geometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QGridLayout*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

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

int QGridLayout_IndexOf(void* ptr, void* widget)
{
	return static_cast<QGridLayout*>(ptr)->indexOf(static_cast<QWidget*>(widget));
}

int QGridLayout_IndexOfDefault(void* ptr, void* widget)
{
	return static_cast<QGridLayout*>(ptr)->QGridLayout::indexOf(static_cast<QWidget*>(widget));
}

char QGridLayout_IsEmpty(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->isEmpty();
}

char QGridLayout_IsEmptyDefault(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->QGridLayout::isEmpty();
}

void* QGridLayout_Layout(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->layout();
}

void* QGridLayout_LayoutDefault(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->QGridLayout::layout();
}

void QGridLayout_TimerEvent(void* ptr, void* event)
{
	static_cast<QGridLayout*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGridLayout_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGridLayout*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGridLayout_CustomEvent(void* ptr, void* event)
{
	static_cast<QGridLayout*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGridLayout_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGridLayout*>(ptr), "deleteLater");
}

void QGridLayout_DeleteLaterDefault(void* ptr)
{
	static_cast<QGridLayout*>(ptr)->QGridLayout::deleteLater();
}

void QGridLayout_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGridLayout*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGridLayout_Event(void* ptr, void* e)
{
	return static_cast<QGridLayout*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QGridLayout_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGridLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGridLayout_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGridLayout*>(ptr)->QGridLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGridLayout_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGridLayout*>(ptr)->metaObject());
}

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

void* QGridLayout_SpacerItem(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->spacerItem();
}

void* QGridLayout_SpacerItemDefault(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->QGridLayout::spacerItem();
}

void* QGridLayout_Widget(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->widget();
}

void* QGridLayout_WidgetDefault(void* ptr)
{
	return static_cast<QGridLayout*>(ptr)->QGridLayout::widget();
}

class MyQGroupBox: public QGroupBox
{
public:
	MyQGroupBox(QWidget *parent) : QGroupBox(parent) {};
	MyQGroupBox(const QString &title, QWidget *parent) : QGroupBox(title, parent) {};
	void setChecked(bool checked) { callbackQGroupBox_SetChecked(this, checked); };
	void changeEvent(QEvent * ev) { callbackQGroupBox_ChangeEvent(this, ev); };
	void Signal_Clicked(bool checked) { callbackQGroupBox_Clicked(this, checked); };
	void focusInEvent(QFocusEvent * fe) { callbackQGroupBox_FocusInEvent(this, fe); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQGroupBox_MinimumSizeHint(const_cast<MyQGroupBox*>(this))); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQGroupBox_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQGroupBox_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQGroupBox_MouseReleaseEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQGroupBox_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * e) { callbackQGroupBox_ResizeEvent(this, e); };
	void Signal_Toggled(bool on) { callbackQGroupBox_Toggled(this, on); };
	void actionEvent(QActionEvent * event) { callbackQGroupBox_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQGroupBox_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQGroupBox_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQGroupBox_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQGroupBox_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQGroupBox_EnterEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQGroupBox_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQGroupBox_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQGroupBox_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQGroupBox_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQGroupBox_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQGroupBox_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQGroupBox_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQGroupBox_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQGroupBox_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQGroupBox_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQGroupBox_SizeHint(const_cast<MyQGroupBox*>(this))); };
	bool close() { return callbackQGroupBox_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQGroupBox_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQGroupBox_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQGroupBox_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQGroupBox_HasHeightForWidth(const_cast<MyQGroupBox*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQGroupBox_HeightForWidth(const_cast<MyQGroupBox*>(this), w); };
	void hide() { callbackQGroupBox_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQGroupBox_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGroupBox_InputMethodQuery(const_cast<MyQGroupBox*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQGroupBox_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQGroupBox_KeyReleaseEvent(this, event); };
	void lower() { callbackQGroupBox_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQGroupBox_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQGroupBox_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQGroupBox_Raise(this); };
	void repaint() { callbackQGroupBox_Repaint(this); };
	void setDisabled(bool disable) { callbackQGroupBox_SetDisabled(this, disable); };
	void setFocus() { callbackQGroupBox_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQGroupBox_SetHidden(this, hidden); };
	void show() { callbackQGroupBox_Show(this); };
	void showFullScreen() { callbackQGroupBox_ShowFullScreen(this); };
	void showMaximized() { callbackQGroupBox_ShowMaximized(this); };
	void showMinimized() { callbackQGroupBox_ShowMinimized(this); };
	void showNormal() { callbackQGroupBox_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQGroupBox_TabletEvent(this, event); };
	void update() { callbackQGroupBox_Update(this); };
	void updateMicroFocus() { callbackQGroupBox_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQGroupBox_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQGroupBox_TimerEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGroupBox_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGroupBox_CustomEvent(this, event); };
	void deleteLater() { callbackQGroupBox_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGroupBox_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGroupBox_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGroupBox_MetaObject(const_cast<MyQGroupBox*>(this))); };
};

long long QGroupBox_Alignment(void* ptr)
{
	return static_cast<QGroupBox*>(ptr)->alignment();
}

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_SetFlat(void* ptr, char flat)
{
	static_cast<QGroupBox*>(ptr)->setFlat(flat != 0);
}

void QGroupBox_SetTitle(void* ptr, char* title)
{
	static_cast<QGroupBox*>(ptr)->setTitle(QString(title));
}

char* QGroupBox_Title(void* ptr)
{
	return const_cast<char*>(static_cast<QGroupBox*>(ptr)->title().toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QGroupBox_NewQGroupBox(void* parent)
{
	return new MyQGroupBox(static_cast<QWidget*>(parent));
}

void* QGroupBox_NewQGroupBox2(char* title, void* parent)
{
	return new MyQGroupBox(QString(title), static_cast<QWidget*>(parent));
}

void QGroupBox_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QGroupBox*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QGroupBox_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::changeEvent(static_cast<QEvent*>(ev));
}

void QGroupBox_ChildEvent(void* ptr, void* c)
{
	static_cast<QGroupBox*>(ptr)->childEvent(static_cast<QChildEvent*>(c));
}

void QGroupBox_ConnectClicked(void* ptr)
{
	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));
}

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);
}

char QGroupBox_Event(void* ptr, void* e)
{
	return static_cast<QGroupBox*>(ptr)->event(static_cast<QEvent*>(e));
}

void QGroupBox_FocusInEvent(void* ptr, void* fe)
{
	static_cast<QGroupBox*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(fe));
}

void QGroupBox_FocusInEventDefault(void* ptr, void* fe)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::focusInEvent(static_cast<QFocusEvent*>(fe));
}

void QGroupBox_InitStyleOption(void* ptr, void* option)
{
	static_cast<QGroupBox*>(ptr)->initStyleOption(static_cast<QStyleOptionGroupBox*>(option));
}

void* QGroupBox_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QGroupBox*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QGroupBox_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QGroupBox*>(ptr)->QGroupBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QGroupBox_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QGroupBox_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QGroupBox_MousePressEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QGroupBox_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QGroupBox_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QGroupBox_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QGroupBox_PaintEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QGroupBox_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::paintEvent(static_cast<QPaintEvent*>(event));
}

void QGroupBox_ResizeEvent(void* ptr, void* e)
{
	static_cast<QGroupBox*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(e));
}

void QGroupBox_ResizeEventDefault(void* ptr, void* e)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::resizeEvent(static_cast<QResizeEvent*>(e));
}

void QGroupBox_ConnectToggled(void* ptr)
{
	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));
}

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_ActionEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QGroupBox_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::actionEvent(static_cast<QActionEvent*>(event));
}

void QGroupBox_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QGroupBox_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QGroupBox_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QGroupBox_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QGroupBox_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QGroupBox_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QGroupBox_DropEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QGroupBox_DropEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::dropEvent(static_cast<QDropEvent*>(event));
}

void QGroupBox_EnterEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QGroupBox_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::enterEvent(static_cast<QEvent*>(event));
}

void QGroupBox_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGroupBox_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QGroupBox_HideEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QGroupBox_HideEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::hideEvent(static_cast<QHideEvent*>(event));
}

void QGroupBox_LeaveEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QGroupBox_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::leaveEvent(static_cast<QEvent*>(event));
}

void QGroupBox_MoveEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QGroupBox_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QGroupBox_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QGroupBox_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::setStyleSheet(QString(styleSheet));
}

void QGroupBox_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QGroupBox_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::setVisible(visible != 0);
}

void QGroupBox_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QGroupBox_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::setWindowModified(vbo != 0);
}

void QGroupBox_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QGroupBox_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::setWindowTitle(QString(vqs));
}

void QGroupBox_ShowEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QGroupBox_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::showEvent(static_cast<QShowEvent*>(event));
}

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

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

char QGroupBox_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QGroupBox_CloseDefault(void* ptr)
{
	return static_cast<QGroupBox*>(ptr)->QGroupBox::close();
}

void QGroupBox_CloseEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QGroupBox_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::closeEvent(static_cast<QCloseEvent*>(event));
}

void QGroupBox_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QGroupBox_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QGroupBox_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QGroupBox*>(ptr)->focusNextPrevChild(next != 0);
}

char QGroupBox_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QGroupBox*>(ptr)->QGroupBox::focusNextPrevChild(next != 0);
}

char QGroupBox_HasHeightForWidth(void* ptr)
{
	return static_cast<QGroupBox*>(ptr)->hasHeightForWidth();
}

char QGroupBox_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QGroupBox*>(ptr)->QGroupBox::hasHeightForWidth();
}

int QGroupBox_HeightForWidth(void* ptr, int w)
{
	return static_cast<QGroupBox*>(ptr)->heightForWidth(w);
}

int QGroupBox_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QGroupBox*>(ptr)->QGroupBox::heightForWidth(w);
}

void QGroupBox_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "hide");
}

void QGroupBox_HideDefault(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::hide();
}

void QGroupBox_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QGroupBox_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QGroupBox_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QGroupBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QGroupBox_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QGroupBox*>(ptr)->QGroupBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QGroupBox_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGroupBox_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QGroupBox_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGroupBox_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QGroupBox_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "lower");
}

void QGroupBox_LowerDefault(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::lower();
}

void QGroupBox_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QGroupBox_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QGroupBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QGroupBox*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QGroupBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QGroupBox*>(ptr)->QGroupBox::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QGroupBox_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "raise");
}

void QGroupBox_RaiseDefault(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::raise();
}

void QGroupBox_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "repaint");
}

void QGroupBox_RepaintDefault(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::repaint();
}

void QGroupBox_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QGroupBox_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::setDisabled(disable != 0);
}

void QGroupBox_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setFocus");
}

void QGroupBox_SetFocus2Default(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::setFocus();
}

void QGroupBox_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QGroupBox_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::setHidden(hidden != 0);
}

void QGroupBox_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "show");
}

void QGroupBox_ShowDefault(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::show();
}

void QGroupBox_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "showFullScreen");
}

void QGroupBox_ShowFullScreenDefault(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::showFullScreen();
}

void QGroupBox_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "showMaximized");
}

void QGroupBox_ShowMaximizedDefault(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::showMaximized();
}

void QGroupBox_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "showMinimized");
}

void QGroupBox_ShowMinimizedDefault(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::showMinimized();
}

void QGroupBox_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "showNormal");
}

void QGroupBox_ShowNormalDefault(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::showNormal();
}

void QGroupBox_TabletEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QGroupBox_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QGroupBox_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "update");
}

void QGroupBox_UpdateDefault(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::update();
}

void QGroupBox_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "updateMicroFocus");
}

void QGroupBox_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::updateMicroFocus();
}

void QGroupBox_WheelEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QGroupBox_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QGroupBox_TimerEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QGroupBox_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QGroupBox*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QGroupBox_CustomEvent(void* ptr, void* event)
{
	static_cast<QGroupBox*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QGroupBox_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "deleteLater");
}

void QGroupBox_DeleteLaterDefault(void* ptr)
{
	static_cast<QGroupBox*>(ptr)->QGroupBox::deleteLater();
}

void QGroupBox_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QGroupBox*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QGroupBox_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QGroupBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QGroupBox_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QGroupBox*>(ptr)->QGroupBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QGroupBox_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QGroupBox*>(ptr)->metaObject());
}

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

void* QHBoxLayout_NewQHBoxLayout()
{
	return new QHBoxLayout();
}

void* QHBoxLayout_NewQHBoxLayout2(void* parent)
{
	return new QHBoxLayout(static_cast<QWidget*>(parent));
}

void QHBoxLayout_DestroyQHBoxLayout(void* ptr)
{
	static_cast<QHBoxLayout*>(ptr)->~QHBoxLayout();
}

void QHBoxLayout_AddItem(void* ptr, void* item)
{
	static_cast<QHBoxLayout*>(ptr)->addItem(static_cast<QLayoutItem*>(item));
}

void QHBoxLayout_AddItemDefault(void* ptr, void* item)
{
	static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::addItem(static_cast<QLayoutItem*>(item));
}

int QHBoxLayout_Count(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->count();
}

int QHBoxLayout_CountDefault(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::count();
}

long long QHBoxLayout_ExpandingDirections(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->expandingDirections();
}

long long QHBoxLayout_ExpandingDirectionsDefault(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::expandingDirections();
}

char QHBoxLayout_HasHeightForWidth(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->hasHeightForWidth();
}

char QHBoxLayout_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::hasHeightForWidth();
}

int QHBoxLayout_HeightForWidth(void* ptr, int w)
{
	return static_cast<QHBoxLayout*>(ptr)->heightForWidth(w);
}

int QHBoxLayout_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::heightForWidth(w);
}

void QHBoxLayout_Invalidate(void* ptr)
{
	static_cast<QHBoxLayout*>(ptr)->invalidate();
}

void QHBoxLayout_InvalidateDefault(void* ptr)
{
	static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::invalidate();
}

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

void* QHBoxLayout_ItemAtDefault(void* ptr, int index)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::itemAt(index);
}

void* QHBoxLayout_MaximumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QHBoxLayout*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QHBoxLayout_MaximumSizeDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QHBoxLayout_MinimumHeightForWidth(void* ptr, int w)
{
	return static_cast<QHBoxLayout*>(ptr)->minimumHeightForWidth(w);
}

int QHBoxLayout_MinimumHeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::minimumHeightForWidth(w);
}

void* QHBoxLayout_MinimumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QHBoxLayout*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QHBoxLayout_MinimumSizeDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QHBoxLayout_SetGeometry(void* ptr, void* r)
{
	static_cast<QHBoxLayout*>(ptr)->setGeometry(*static_cast<QRect*>(r));
}

void QHBoxLayout_SetGeometryDefault(void* ptr, void* r)
{
	static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::setGeometry(*static_cast<QRect*>(r));
}

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

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

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

void* QHBoxLayout_TakeAtDefault(void* ptr, int index)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::takeAt(index);
}

long long QHBoxLayout_ControlTypes(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->controlTypes();
}

long long QHBoxLayout_ControlTypesDefault(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::controlTypes();
}

void* QHBoxLayout_Geometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QHBoxLayout*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

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

int QHBoxLayout_IndexOf(void* ptr, void* widget)
{
	return static_cast<QHBoxLayout*>(ptr)->indexOf(static_cast<QWidget*>(widget));
}

int QHBoxLayout_IndexOfDefault(void* ptr, void* widget)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::indexOf(static_cast<QWidget*>(widget));
}

char QHBoxLayout_IsEmpty(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->isEmpty();
}

char QHBoxLayout_IsEmptyDefault(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::isEmpty();
}

void* QHBoxLayout_Layout(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->layout();
}

void* QHBoxLayout_LayoutDefault(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::layout();
}

void QHBoxLayout_TimerEvent(void* ptr, void* event)
{
	static_cast<QHBoxLayout*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

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

void QHBoxLayout_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QHBoxLayout*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

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

void QHBoxLayout_CustomEvent(void* ptr, void* event)
{
	static_cast<QHBoxLayout*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

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

void QHBoxLayout_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHBoxLayout*>(ptr), "deleteLater");
}

void QHBoxLayout_DeleteLaterDefault(void* ptr)
{
	static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::deleteLater();
}

void QHBoxLayout_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QHBoxLayout*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

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

char QHBoxLayout_Event(void* ptr, void* e)
{
	return static_cast<QHBoxLayout*>(ptr)->event(static_cast<QEvent*>(e));
}

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

char QHBoxLayout_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QHBoxLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QHBoxLayout_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QHBoxLayout_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QHBoxLayout*>(ptr)->metaObject());
}

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

void* QHBoxLayout_SpacerItem(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->spacerItem();
}

void* QHBoxLayout_SpacerItemDefault(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::spacerItem();
}

void* QHBoxLayout_Widget(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->widget();
}

void* QHBoxLayout_WidgetDefault(void* ptr)
{
	return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::widget();
}

class MyQHeaderView: public QHeaderView
{
public:
	MyQHeaderView(Qt::Orientation orientation, QWidget *parent) : QHeaderView(orientation, parent) {};
	void setOffset(int offset) { callbackQHeaderView_SetOffset(this, offset); };
	void currentChanged(const QModelIndex & current, const QModelIndex & old) { callbackQHeaderView_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&old)); };
	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<MyQHeaderView*>(this)); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQHeaderView_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQHeaderView_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQHeaderView_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQHeaderView_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQHeaderView_PaintEvent(this, e); };
	void paintSection(QPainter * painter, const QRect & rect, int logicalIndex) const { callbackQHeaderView_PaintSection(const_cast<MyQHeaderView*>(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<MyQHeaderView*>(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) { callbackQHeaderView_SetModel(this, model); };
	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*>(callbackQHeaderView_SizeHint(const_cast<MyQHeaderView*>(this))); };
	void Signal_SortIndicatorChanged(int logicalIndex, Qt::SortOrder order) { callbackQHeaderView_SortIndicatorChanged(this, logicalIndex, order); };
	int verticalOffset() const { return callbackQHeaderView_VerticalOffset(const_cast<MyQHeaderView*>(this)); };
	bool viewportEvent(QEvent * e) { return callbackQHeaderView_ViewportEvent(this, e) != 0; };
	 ~MyQHeaderView() { callbackQHeaderView_DestroyQHeaderView(this); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQHeaderView_DragLeaveEvent(this, event); };
	void clearSelection() { callbackQHeaderView_ClearSelection(this); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQHeaderView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQHeaderView_CommitData(this, editor); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQHeaderView_DragEnterEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQHeaderView_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQHeaderView_DropEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQHeaderView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQHeaderView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQHeaderView_EditorDestroyed(this, editor); };
	void focusInEvent(QFocusEvent * event) { callbackQHeaderView_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQHeaderView_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQHeaderView_FocusOutEvent(this, event); };
	QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQHeaderView_IndexAt(const_cast<MyQHeaderView*>(this), const_cast<QPoint*>(&point))); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQHeaderView_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQHeaderView_InputMethodQuery(const_cast<MyQHeaderView*>(this), query)); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQHeaderView_IsIndexHidden(const_cast<MyQHeaderView*>(this), const_cast<QModelIndex*>(&index)) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQHeaderView_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { callbackQHeaderView_KeyboardSearch(this, const_cast<char*>(search.toUtf8().prepend("WHITESPACE").constData()+10)); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQHeaderView_MoveCursor(this, cursorAction, modifiers)); };
	void resizeEvent(QResizeEvent * event) { callbackQHeaderView_ResizeEvent(this, event); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQHeaderView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQHeaderView_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() { callbackQHeaderView_ScrollToBottom(this); };
	void scrollToTop() { callbackQHeaderView_ScrollToTop(this); };
	void selectAll() { callbackQHeaderView_SelectAll(this); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQHeaderView_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>(callbackQHeaderView_SelectionCommand(const_cast<MyQHeaderView*>(this), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQHeaderView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	void setRootIndex(const QModelIndex & index) { callbackQHeaderView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQHeaderView_SetSelectionModel(this, selectionModel); };
	int sizeHintForColumn(int column) const { return callbackQHeaderView_SizeHintForColumn(const_cast<MyQHeaderView*>(this), column); };
	int sizeHintForRow(int row) const { return callbackQHeaderView_SizeHintForRow(const_cast<MyQHeaderView*>(this), row); };
	void startDrag(Qt::DropActions supportedActions) { callbackQHeaderView_StartDrag(this, supportedActions); };
	void update(const QModelIndex & index) { callbackQHeaderView_Update(this, const_cast<QModelIndex*>(&index)); };
	void updateGeometries() { callbackQHeaderView_UpdateGeometries(this); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQHeaderView_ViewOptions(const_cast<MyQHeaderView*>(this))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQHeaderView_ViewportSizeHint(const_cast<MyQHeaderView*>(this))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQHeaderView_VisualRect(const_cast<MyQHeaderView*>(this), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQHeaderView_VisualRegionForSelection(const_cast<MyQHeaderView*>(this), const_cast<QItemSelection*>(&selection))); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQHeaderView_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQHeaderView_MinimumSizeHint(const_cast<MyQHeaderView*>(this))); };
	void scrollContentsBy(int dx, int dy) { callbackQHeaderView_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQHeaderView_SetupViewport(this, viewport); };
	void wheelEvent(QWheelEvent * e) { callbackQHeaderView_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQHeaderView_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQHeaderView_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQHeaderView_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQHeaderView_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQHeaderView_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQHeaderView_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQHeaderView_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQHeaderView_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setWindowModified(bool vbo) { callbackQHeaderView_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQHeaderView_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQHeaderView_ShowEvent(this, event); };
	bool close() { return callbackQHeaderView_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQHeaderView_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQHeaderView_HasHeightForWidth(const_cast<MyQHeaderView*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQHeaderView_HeightForWidth(const_cast<MyQHeaderView*>(this), w); };
	void hide() { callbackQHeaderView_Hide(this); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQHeaderView_KeyReleaseEvent(this, event); };
	void lower() { callbackQHeaderView_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQHeaderView_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQHeaderView_Raise(this); };
	void repaint() { callbackQHeaderView_Repaint(this); };
	void setDisabled(bool disable) { callbackQHeaderView_SetDisabled(this, disable); };
	void setFocus() { callbackQHeaderView_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQHeaderView_SetHidden(this, hidden); };
	void show() { callbackQHeaderView_Show(this); };
	void showFullScreen() { callbackQHeaderView_ShowFullScreen(this); };
	void showMaximized() { callbackQHeaderView_ShowMaximized(this); };
	void showMinimized() { callbackQHeaderView_ShowMinimized(this); };
	void showNormal() { callbackQHeaderView_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQHeaderView_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQHeaderView_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQHeaderView_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQHeaderView_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQHeaderView_CustomEvent(this, event); };
	void deleteLater() { callbackQHeaderView_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQHeaderView_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQHeaderView_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQHeaderView_MetaObject(const_cast<MyQHeaderView*>(this))); };
};

char QHeaderView_CascadingSectionResizes(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->cascadingSectionResizes();
}

long long QHeaderView_DefaultAlignment(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->defaultAlignment();
}

int QHeaderView_DefaultSectionSize(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->defaultSectionSize();
}

char QHeaderView_HighlightSections(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->highlightSections();
}

char QHeaderView_IsSortIndicatorShown(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->isSortIndicatorShown();
}

int QHeaderView_MaximumSectionSize(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->maximumSectionSize();
}

int QHeaderView_MinimumSectionSize(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->minimumSectionSize();
}

void QHeaderView_ResetDefaultSectionSize(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->resetDefaultSectionSize();
}

void QHeaderView_ResizeSection(void* ptr, int logicalIndex, int size)
{
	static_cast<QHeaderView*>(ptr)->resizeSection(logicalIndex, size);
}

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_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_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);
}

char QHeaderView_StretchLastSection(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->stretchLastSection();
}

void* QHeaderView_NewQHeaderView(long long orientation, void* parent)
{
	return new MyQHeaderView(static_cast<Qt::Orientation>(orientation), static_cast<QWidget*>(parent));
}

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));
}

char QHeaderView_Event(void* ptr, void* e)
{
	return static_cast<QHeaderView*>(ptr)->event(static_cast<QEvent*>(e));
}

void QHeaderView_ConnectGeometriesChanged(void* ptr)
{
	QObject::connect(static_cast<QHeaderView*>(ptr), static_cast<void (QHeaderView::*)()>(&QHeaderView::geometriesChanged), static_cast<MyQHeaderView*>(ptr), static_cast<void (MyQHeaderView::*)()>(&MyQHeaderView::Signal_GeometriesChanged));
}

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)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "headerDataChanged", Q_ARG(Qt::Orientation, static_cast<Qt::Orientation>(orientation)), Q_ARG(int, logicalFirst), Q_ARG(int, 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);
}

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_IsSectionHidden(void* ptr, int logicalIndex)
{
	return static_cast<QHeaderView*>(ptr)->isSectionHidden(logicalIndex);
}

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_LogicalIndexAt3(void* ptr, void* pos)
{
	return static_cast<QHeaderView*>(ptr)->logicalIndexAt(*static_cast<QPoint*>(pos));
}

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);
}

void QHeaderView_MouseDoubleClickEvent(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QHeaderView_MouseDoubleClickEventDefault(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QHeaderView_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QHeaderView_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QHeaderView_MousePressEvent(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QHeaderView_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QHeaderView_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QHeaderView_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

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_PaintEvent(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->paintEvent(static_cast<QPaintEvent*>(e));
}

void QHeaderView_PaintEventDefault(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::paintEvent(static_cast<QPaintEvent*>(e));
}

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();
}

int QHeaderView_ResizeContentsPrecision(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->resizeContentsPrecision();
}

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");
}

char QHeaderView_RestoreState(void* ptr, char* state)
{
	return static_cast<QHeaderView*>(ptr)->restoreState(QByteArray::fromHex(QString(state).toUtf8()));
}

char* QHeaderView_SaveState(void* ptr)
{
	return const_cast<char*>(static_cast<QHeaderView*>(ptr)->saveState().toHex().prepend("WHITESPACE").constData()+10);
}

void QHeaderView_ConnectSectionClicked(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, logicalFirst), Q_ARG(int, 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(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, logicalFirst), Q_ARG(int, 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_SetModel(void* ptr, void* model)
{
	static_cast<QHeaderView*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}

void QHeaderView_SetModelDefault(void* ptr, void* model)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::setModel(static_cast<QAbstractItemModel*>(model));
}

void QHeaderView_SetOffsetToLastSection(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setOffsetToLastSection");
}

void QHeaderView_SetOffsetToSectionPosition(void* ptr, int visualSectionNumber)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setOffsetToSectionPosition", Q_ARG(int, 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_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_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QHeaderView*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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

void QHeaderView_ConnectSortIndicatorChanged(void* ptr)
{
	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));
}

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();
}

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();
}

char QHeaderView_ViewportEvent(void* ptr, void* e)
{
	return static_cast<QHeaderView*>(ptr)->viewportEvent(static_cast<QEvent*>(e));
}

char QHeaderView_ViewportEventDefault(void* ptr, void* e)
{
	return static_cast<QHeaderView*>(ptr)->QHeaderView::viewportEvent(static_cast<QEvent*>(e));
}

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)
{

}

void QHeaderView_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QHeaderView_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

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

void QHeaderView_ClearSelectionDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::clearSelection();
}

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

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

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

void QHeaderView_CommitDataDefault(void* ptr, void* editor)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::commitData(static_cast<QWidget*>(editor));
}

void QHeaderView_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QHeaderView_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QHeaderView_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QHeaderView_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QHeaderView_DropEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QHeaderView_DropEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::dropEvent(static_cast<QDropEvent*>(event));
}

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

void QHeaderView_EditDefault(void* ptr, void* index)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::edit(*static_cast<QModelIndex*>(index));
}

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

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

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

void QHeaderView_EditorDestroyedDefault(void* ptr, void* editor)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::editorDestroyed(static_cast<QObject*>(editor));
}

void QHeaderView_FocusInEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QHeaderView_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QHeaderView_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QHeaderView*>(ptr)->focusNextPrevChild(next != 0);
}

char QHeaderView_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QHeaderView*>(ptr)->QHeaderView::focusNextPrevChild(next != 0);
}

void QHeaderView_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QHeaderView_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::focusOutEvent(static_cast<QFocusEvent*>(event));
}

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)));
}

void QHeaderView_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QHeaderView_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QHeaderView_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QHeaderView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QHeaderView_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QHeaderView*>(ptr)->QHeaderView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

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_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QHeaderView_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QHeaderView_KeyboardSearch(void* ptr, char* search)
{
	static_cast<QHeaderView*>(ptr)->keyboardSearch(QString(search));
}

void QHeaderView_KeyboardSearchDefault(void* ptr, char* search)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::keyboardSearch(QString(search));
}

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_ResizeEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QHeaderView_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::resizeEvent(static_cast<QResizeEvent*>(event));
}

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

void QHeaderView_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
}

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

void QHeaderView_RowsInsertedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
}

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_ScrollToBottom(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "scrollToBottom");
}

void QHeaderView_ScrollToBottomDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::scrollToBottom();
}

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

void QHeaderView_ScrollToTopDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::scrollToTop();
}

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

void QHeaderView_SelectAllDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::selectAll();
}

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

void QHeaderView_SelectionChangedDefault(void* ptr, void* selected, void* deselected)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

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

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

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

void QHeaderView_SetCurrentIndexDefault(void* ptr, void* index)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::setCurrentIndex(*static_cast<QModelIndex*>(index));
}

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

void QHeaderView_SetRootIndexDefault(void* ptr, void* index)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::setRootIndex(*static_cast<QModelIndex*>(index));
}

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

void QHeaderView_SetSelectionModelDefault(void* ptr, void* selectionModel)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

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

int QHeaderView_SizeHintForColumnDefault(void* ptr, int column)
{
	return static_cast<QHeaderView*>(ptr)->QHeaderView::sizeHintForColumn(column);
}

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

int QHeaderView_SizeHintForRowDefault(void* ptr, int row)
{
	return static_cast<QHeaderView*>(ptr)->QHeaderView::sizeHintForRow(row);
}

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

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

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

void QHeaderView_UpdateDefault(void* ptr, void* index)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::update(*static_cast<QModelIndex*>(index));
}

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

void QHeaderView_UpdateGeometriesDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::updateGeometries();
}

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

void* QHeaderView_ViewOptionsDefault(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QHeaderView*>(ptr)->QHeaderView::viewOptions());
}

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

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

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)));
}

void QHeaderView_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QHeaderView_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void* QHeaderView_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QHeaderView*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QHeaderView_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QHeaderView*>(ptr)->QHeaderView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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

void QHeaderView_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::scrollContentsBy(dx, dy);
}

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

void QHeaderView_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::setupViewport(static_cast<QWidget*>(viewport));
}

void QHeaderView_WheelEvent(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QHeaderView_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QHeaderView_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QHeaderView*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QHeaderView_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::changeEvent(static_cast<QEvent*>(ev));
}

void QHeaderView_ActionEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QHeaderView_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::actionEvent(static_cast<QActionEvent*>(event));
}

void QHeaderView_EnterEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QHeaderView_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::enterEvent(static_cast<QEvent*>(event));
}

void QHeaderView_HideEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QHeaderView_HideEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::hideEvent(static_cast<QHideEvent*>(event));
}

void QHeaderView_LeaveEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QHeaderView_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::leaveEvent(static_cast<QEvent*>(event));
}

void QHeaderView_MoveEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QHeaderView_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::moveEvent(static_cast<QMoveEvent*>(event));
}

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

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

void QHeaderView_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QHeaderView_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::setStyleSheet(QString(styleSheet));
}

void QHeaderView_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QHeaderView_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::setWindowModified(vbo != 0);
}

void QHeaderView_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QHeaderView_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::setWindowTitle(QString(vqs));
}

void QHeaderView_ShowEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QHeaderView_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::showEvent(static_cast<QShowEvent*>(event));
}

char QHeaderView_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QHeaderView_CloseDefault(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->QHeaderView::close();
}

void QHeaderView_CloseEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QHeaderView_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::closeEvent(static_cast<QCloseEvent*>(event));
}

char QHeaderView_HasHeightForWidth(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->hasHeightForWidth();
}

char QHeaderView_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QHeaderView*>(ptr)->QHeaderView::hasHeightForWidth();
}

int QHeaderView_HeightForWidth(void* ptr, int w)
{
	return static_cast<QHeaderView*>(ptr)->heightForWidth(w);
}

int QHeaderView_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QHeaderView*>(ptr)->QHeaderView::heightForWidth(w);
}

void QHeaderView_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "hide");
}

void QHeaderView_HideDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::hide();
}

void QHeaderView_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QHeaderView_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QHeaderView_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "lower");
}

void QHeaderView_LowerDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::lower();
}

char QHeaderView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QHeaderView*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QHeaderView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QHeaderView*>(ptr)->QHeaderView::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QHeaderView_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "raise");
}

void QHeaderView_RaiseDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::raise();
}

void QHeaderView_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "repaint");
}

void QHeaderView_RepaintDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::repaint();
}

void QHeaderView_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QHeaderView_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::setDisabled(disable != 0);
}

void QHeaderView_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setFocus");
}

void QHeaderView_SetFocus2Default(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::setFocus();
}

void QHeaderView_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QHeaderView_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::setHidden(hidden != 0);
}

void QHeaderView_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "show");
}

void QHeaderView_ShowDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::show();
}

void QHeaderView_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "showFullScreen");
}

void QHeaderView_ShowFullScreenDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::showFullScreen();
}

void QHeaderView_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "showMaximized");
}

void QHeaderView_ShowMaximizedDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::showMaximized();
}

void QHeaderView_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "showMinimized");
}

void QHeaderView_ShowMinimizedDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::showMinimized();
}

void QHeaderView_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "showNormal");
}

void QHeaderView_ShowNormalDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::showNormal();
}

void QHeaderView_TabletEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QHeaderView_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QHeaderView_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "updateMicroFocus");
}

void QHeaderView_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::updateMicroFocus();
}

void QHeaderView_ChildEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

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

void QHeaderView_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QHeaderView*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QHeaderView_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QHeaderView_CustomEvent(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QHeaderView_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::customEvent(static_cast<QEvent*>(event));
}

void QHeaderView_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "deleteLater");
}

void QHeaderView_DeleteLaterDefault(void* ptr)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::deleteLater();
}

void QHeaderView_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QHeaderView*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QHeaderView_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QHeaderView*>(ptr)->QHeaderView::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QHeaderView_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QHeaderView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QHeaderView_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QHeaderView*>(ptr)->QHeaderView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QHeaderView_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QHeaderView*>(ptr)->metaObject());
}

void* QHeaderView_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QHeaderView*>(ptr)->QHeaderView::metaObject());
}

class MyQInputDialog: public QInputDialog
{
public:
	MyQInputDialog(QWidget *parent, Qt::WindowFlags flags) : QInputDialog(parent, flags) {};
	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*>(callbackQInputDialog_MinimumSizeHint(const_cast<MyQInputDialog*>(this))); };
	void setVisible(bool visible) { callbackQInputDialog_SetVisible(this, visible); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQInputDialog_SizeHint(const_cast<MyQInputDialog*>(this))); };
	void Signal_TextValueChanged(const QString & text) { callbackQInputDialog_TextValueChanged(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_TextValueSelected(const QString & text) { callbackQInputDialog_TextValueSelected(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void accept() { callbackQInputDialog_Accept(this); };
	void closeEvent(QCloseEvent * e) { callbackQInputDialog_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQInputDialog_ContextMenuEvent(this, e); };
	int exec() { return callbackQInputDialog_Exec(this); };
	void keyPressEvent(QKeyEvent * e) { callbackQInputDialog_KeyPressEvent(this, e); };
	void reject() { callbackQInputDialog_Reject(this); };
	void resizeEvent(QResizeEvent * vqr) { callbackQInputDialog_ResizeEvent(this, vqr); };
	void showEvent(QShowEvent * event) { callbackQInputDialog_ShowEvent(this, event); };
	void actionEvent(QActionEvent * event) { callbackQInputDialog_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQInputDialog_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQInputDialog_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQInputDialog_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQInputDialog_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQInputDialog_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQInputDialog_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQInputDialog_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQInputDialog_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQInputDialog_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQInputDialog_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQInputDialog_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQInputDialog_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQInputDialog_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setWindowModified(bool vbo) { callbackQInputDialog_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQInputDialog_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void changeEvent(QEvent * event) { callbackQInputDialog_ChangeEvent(this, event); };
	bool close() { return callbackQInputDialog_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQInputDialog_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQInputDialog_HasHeightForWidth(const_cast<MyQInputDialog*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQInputDialog_HeightForWidth(const_cast<MyQInputDialog*>(this), w); };
	void hide() { callbackQInputDialog_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQInputDialog_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQInputDialog_InputMethodQuery(const_cast<MyQInputDialog*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQInputDialog_KeyReleaseEvent(this, event); };
	void lower() { callbackQInputDialog_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQInputDialog_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQInputDialog_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQInputDialog_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQInputDialog_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQInputDialog_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQInputDialog_Raise(this); };
	void repaint() { callbackQInputDialog_Repaint(this); };
	void setDisabled(bool disable) { callbackQInputDialog_SetDisabled(this, disable); };
	void setFocus() { callbackQInputDialog_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQInputDialog_SetHidden(this, hidden); };
	void show() { callbackQInputDialog_Show(this); };
	void showFullScreen() { callbackQInputDialog_ShowFullScreen(this); };
	void showMaximized() { callbackQInputDialog_ShowMaximized(this); };
	void showMinimized() { callbackQInputDialog_ShowMinimized(this); };
	void showNormal() { callbackQInputDialog_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQInputDialog_TabletEvent(this, event); };
	void update() { callbackQInputDialog_Update(this); };
	void updateMicroFocus() { callbackQInputDialog_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQInputDialog_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQInputDialog_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQInputDialog_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQInputDialog_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQInputDialog_CustomEvent(this, event); };
	void deleteLater() { callbackQInputDialog_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQInputDialog_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQInputDialog_MetaObject(const_cast<MyQInputDialog*>(this))); };
};

char* QInputDialog_CancelButtonText(void* ptr)
{
	return const_cast<char*>(static_cast<QInputDialog*>(ptr)->cancelButtonText().toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QInputDialog_ComboBoxItems(void* ptr)
{
	return const_cast<char*>(static_cast<QInputDialog*>(ptr)->comboBoxItems().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

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_DoubleValue(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->doubleValue();
}

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();
}

char QInputDialog_IsComboBoxEditable(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->isComboBoxEditable();
}

char* QInputDialog_LabelText(void* ptr)
{
	return const_cast<char*>(static_cast<QInputDialog*>(ptr)->labelText().toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QInputDialog_OkButtonText(void* ptr)
{
	return const_cast<char*>(static_cast<QInputDialog*>(ptr)->okButtonText().toUtf8().prepend("WHITESPACE").constData()+10);
}

long long QInputDialog_Options(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->options();
}

void QInputDialog_SetCancelButtonText(void* ptr, char* text)
{
	static_cast<QInputDialog*>(ptr)->setCancelButtonText(QString(text));
}

void QInputDialog_SetComboBoxEditable(void* ptr, char editable)
{
	static_cast<QInputDialog*>(ptr)->setComboBoxEditable(editable != 0);
}

void QInputDialog_SetComboBoxItems(void* ptr, char* items)
{
	static_cast<QInputDialog*>(ptr)->setComboBoxItems(QString(items).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_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_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, char* text)
{
	static_cast<QInputDialog*>(ptr)->setLabelText(QString(text));
}

void QInputDialog_SetOkButtonText(void* ptr, char* text)
{
	static_cast<QInputDialog*>(ptr)->setOkButtonText(QString(text));
}

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, char* text)
{
	static_cast<QInputDialog*>(ptr)->setTextValue(QString(text));
}

long long QInputDialog_TextEchoMode(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->textEchoMode();
}

char* QInputDialog_TextValue(void* ptr)
{
	return const_cast<char*>(static_cast<QInputDialog*>(ptr)->textValue().toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QInputDialog_NewQInputDialog(void* parent, long long flags)
{
	return new MyQInputDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}

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);
}

void QInputDialog_ConnectDoubleValueChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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, char* title, char* label, double value, double min, double max, int decimals, char ok, long long flags)
{
	return QInputDialog::getDouble(static_cast<QWidget*>(parent), QString(title), QString(label), value, min, max, decimals, NULL, static_cast<Qt::WindowType>(flags));
}

int QInputDialog_QInputDialog_GetInt(void* parent, char* title, char* label, int value, int min, int max, int step, char ok, long long flags)
{
	return QInputDialog::getInt(static_cast<QWidget*>(parent), QString(title), QString(label), value, min, max, step, NULL, static_cast<Qt::WindowType>(flags));
}

char* QInputDialog_QInputDialog_GetItem(void* parent, char* title, char* label, char* items, int current, char editable, char ok, long long flags, long long inputMethodHints)
{
	return const_cast<char*>(QInputDialog::getItem(static_cast<QWidget*>(parent), QString(title), QString(label), QString(items).split("|", QString::SkipEmptyParts), current, editable != 0, NULL, static_cast<Qt::WindowType>(flags), static_cast<Qt::InputMethodHint>(inputMethodHints)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QInputDialog_QInputDialog_GetMultiLineText(void* parent, char* title, char* label, char* text, char ok, long long flags, long long inputMethodHints)
{
	return const_cast<char*>(QInputDialog::getMultiLineText(static_cast<QWidget*>(parent), QString(title), QString(label), QString(text), NULL, static_cast<Qt::WindowType>(flags), static_cast<Qt::InputMethodHint>(inputMethodHints)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QInputDialog_QInputDialog_GetText(void* parent, char* title, char* label, long long mode, char* text, char ok, long long flags, long long inputMethodHints)
{
	return const_cast<char*>(QInputDialog::getText(static_cast<QWidget*>(parent), QString(title), QString(label), static_cast<QLineEdit::EchoMode>(mode), QString(text), NULL, static_cast<Qt::WindowType>(flags), static_cast<Qt::InputMethodHint>(inputMethodHints)).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QInputDialog_ConnectIntValueChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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);
}

void* QInputDialog_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QInputDialog*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QInputDialog_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QInputDialog*>(ptr)->QInputDialog::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QInputDialog_Open(void* ptr, void* receiver, char* member)
{
	static_cast<QInputDialog*>(ptr)->open(static_cast<QObject*>(receiver), const_cast<const char*>(member));
}

void QInputDialog_SetDoubleRange(void* ptr, double min, double max)
{
	static_cast<QInputDialog*>(ptr)->setDoubleRange(min, max);
}

void QInputDialog_SetIntRange(void* ptr, int min, int max)
{
	static_cast<QInputDialog*>(ptr)->setIntRange(min, max);
}

void QInputDialog_SetOption(void* ptr, long long option, char on)
{
	static_cast<QInputDialog*>(ptr)->setOption(static_cast<QInputDialog::InputDialogOption>(option), on != 0);
}

void QInputDialog_SetVisible(void* ptr, char visible)
{
	static_cast<QInputDialog*>(ptr)->setVisible(visible != 0);
}

void QInputDialog_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::setVisible(visible != 0);
}

void* QInputDialog_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QInputDialog*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QInputDialog_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QInputDialog*>(ptr)->QInputDialog::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

char QInputDialog_TestOption(void* ptr, long long option)
{
	return static_cast<QInputDialog*>(ptr)->testOption(static_cast<QInputDialog::InputDialogOption>(option));
}

void QInputDialog_ConnectTextValueChanged(void* ptr)
{
	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));
}

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, char* text)
{
	static_cast<QInputDialog*>(ptr)->textValueChanged(QString(text));
}

void QInputDialog_ConnectTextValueSelected(void* ptr)
{
	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));
}

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, char* text)
{
	static_cast<QInputDialog*>(ptr)->textValueSelected(QString(text));
}

void QInputDialog_DestroyQInputDialog(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->~QInputDialog();
}

void QInputDialog_Accept(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "accept");
}

void QInputDialog_AcceptDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::accept();
}

void QInputDialog_CloseEvent(void* ptr, void* e)
{
	static_cast<QInputDialog*>(ptr)->closeEvent(static_cast<QCloseEvent*>(e));
}

void QInputDialog_CloseEventDefault(void* ptr, void* e)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::closeEvent(static_cast<QCloseEvent*>(e));
}

void QInputDialog_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QInputDialog*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QInputDialog_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

int QInputDialog_Exec(void* ptr)
{
	int returnArg;
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "exec", Q_RETURN_ARG(int, returnArg));
	return returnArg;
}

int QInputDialog_ExecDefault(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->QInputDialog::exec();
}

void QInputDialog_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QInputDialog*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QInputDialog_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QInputDialog_Reject(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "reject");
}

void QInputDialog_RejectDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::reject();
}

void QInputDialog_ResizeEvent(void* ptr, void* vqr)
{
	static_cast<QInputDialog*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QInputDialog_ResizeEventDefault(void* ptr, void* vqr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QInputDialog_ShowEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QInputDialog_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::showEvent(static_cast<QShowEvent*>(event));
}

void QInputDialog_ActionEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QInputDialog_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::actionEvent(static_cast<QActionEvent*>(event));
}

void QInputDialog_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QInputDialog_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QInputDialog_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QInputDialog_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QInputDialog_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QInputDialog_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QInputDialog_DropEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QInputDialog_DropEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::dropEvent(static_cast<QDropEvent*>(event));
}

void QInputDialog_EnterEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QInputDialog_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::enterEvent(static_cast<QEvent*>(event));
}

void QInputDialog_FocusInEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QInputDialog_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QInputDialog_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QInputDialog_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QInputDialog_HideEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QInputDialog_HideEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::hideEvent(static_cast<QHideEvent*>(event));
}

void QInputDialog_LeaveEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QInputDialog_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::leaveEvent(static_cast<QEvent*>(event));
}

void QInputDialog_MoveEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QInputDialog_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::moveEvent(static_cast<QMoveEvent*>(event));
}

void QInputDialog_PaintEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QInputDialog_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::paintEvent(static_cast<QPaintEvent*>(event));
}

void QInputDialog_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QInputDialog_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::setEnabled(vbo != 0);
}

void QInputDialog_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QInputDialog_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::setStyleSheet(QString(styleSheet));
}

void QInputDialog_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QInputDialog_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::setWindowModified(vbo != 0);
}

void QInputDialog_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QInputDialog_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::setWindowTitle(QString(vqs));
}

void QInputDialog_ChangeEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QInputDialog_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::changeEvent(static_cast<QEvent*>(event));
}

char QInputDialog_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QInputDialog_CloseDefault(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->QInputDialog::close();
}

char QInputDialog_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QInputDialog*>(ptr)->focusNextPrevChild(next != 0);
}

char QInputDialog_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QInputDialog*>(ptr)->QInputDialog::focusNextPrevChild(next != 0);
}

char QInputDialog_HasHeightForWidth(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->hasHeightForWidth();
}

char QInputDialog_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QInputDialog*>(ptr)->QInputDialog::hasHeightForWidth();
}

int QInputDialog_HeightForWidth(void* ptr, int w)
{
	return static_cast<QInputDialog*>(ptr)->heightForWidth(w);
}

int QInputDialog_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QInputDialog*>(ptr)->QInputDialog::heightForWidth(w);
}

void QInputDialog_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "hide");
}

void QInputDialog_HideDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::hide();
}

void QInputDialog_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QInputDialog_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QInputDialog_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QInputDialog*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QInputDialog_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QInputDialog*>(ptr)->QInputDialog::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QInputDialog_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QInputDialog_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QInputDialog_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "lower");
}

void QInputDialog_LowerDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::lower();
}

void QInputDialog_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QInputDialog_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QInputDialog_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QInputDialog_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QInputDialog_MousePressEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QInputDialog_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QInputDialog_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QInputDialog_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QInputDialog_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QInputDialog*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QInputDialog_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QInputDialog*>(ptr)->QInputDialog::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QInputDialog_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "raise");
}

void QInputDialog_RaiseDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::raise();
}

void QInputDialog_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "repaint");
}

void QInputDialog_RepaintDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::repaint();
}

void QInputDialog_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QInputDialog_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::setDisabled(disable != 0);
}

void QInputDialog_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "setFocus");
}

void QInputDialog_SetFocus2Default(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::setFocus();
}

void QInputDialog_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QInputDialog_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::setHidden(hidden != 0);
}

void QInputDialog_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "show");
}

void QInputDialog_ShowDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::show();
}

void QInputDialog_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "showFullScreen");
}

void QInputDialog_ShowFullScreenDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::showFullScreen();
}

void QInputDialog_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "showMaximized");
}

void QInputDialog_ShowMaximizedDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::showMaximized();
}

void QInputDialog_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "showMinimized");
}

void QInputDialog_ShowMinimizedDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::showMinimized();
}

void QInputDialog_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "showNormal");
}

void QInputDialog_ShowNormalDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::showNormal();
}

void QInputDialog_TabletEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QInputDialog_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QInputDialog_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "update");
}

void QInputDialog_UpdateDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::update();
}

void QInputDialog_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "updateMicroFocus");
}

void QInputDialog_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::updateMicroFocus();
}

void QInputDialog_WheelEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QInputDialog_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QInputDialog_TimerEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QInputDialog_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::timerEvent(static_cast<QTimerEvent*>(event));
}

void QInputDialog_ChildEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QInputDialog_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::childEvent(static_cast<QChildEvent*>(event));
}

void QInputDialog_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QInputDialog*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QInputDialog_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QInputDialog_CustomEvent(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QInputDialog_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::customEvent(static_cast<QEvent*>(event));
}

void QInputDialog_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "deleteLater");
}

void QInputDialog_DeleteLaterDefault(void* ptr)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::deleteLater();
}

void QInputDialog_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QInputDialog*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QInputDialog_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QInputDialog*>(ptr)->QInputDialog::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void* QInputDialog_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QInputDialog*>(ptr)->metaObject());
}

void* QInputDialog_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QInputDialog*>(ptr)->QInputDialog::metaObject());
}

class MyQItemDelegate: public QItemDelegate
{
public:
	MyQItemDelegate(QObject *parent) : QItemDelegate(parent) {};
	QWidget * createEditor(QWidget * parent, const QStyleOptionViewItem & option, const QModelIndex & index) const { return static_cast<QWidget*>(callbackQItemDelegate_CreateEditor(const_cast<MyQItemDelegate*>(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<MyQItemDelegate*>(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<MyQItemDelegate*>(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 { callbackQItemDelegate_DrawDisplay(const_cast<MyQItemDelegate*>(this), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QRect*>(&rect), const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void drawFocus(QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect) const { callbackQItemDelegate_DrawFocus(const_cast<MyQItemDelegate*>(this), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QRect*>(&rect)); };
	bool editorEvent(QEvent * event, QAbstractItemModel * model, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQItemDelegate_EditorEvent(this, event, model, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)) != 0; };
	void paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQItemDelegate_Paint(const_cast<MyQItemDelegate*>(this), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	void setEditorData(QWidget * editor, const QModelIndex & index) const { callbackQItemDelegate_SetEditorData(const_cast<MyQItemDelegate*>(this), editor, const_cast<QModelIndex*>(&index)); };
	void setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex & index) const { callbackQItemDelegate_SetModelData(const_cast<MyQItemDelegate*>(this), editor, model, const_cast<QModelIndex*>(&index)); };
	QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex & index) const { return *static_cast<QSize*>(callbackQItemDelegate_SizeHint(const_cast<MyQItemDelegate*>(this), const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index))); };
	void updateEditorGeometry(QWidget * editor, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQItemDelegate_UpdateEditorGeometry(const_cast<MyQItemDelegate*>(this), editor, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	void destroyEditor(QWidget * editor, const QModelIndex & index) const { callbackQItemDelegate_DestroyEditor(const_cast<MyQItemDelegate*>(this), editor, const_cast<QModelIndex*>(&index)); };
	bool helpEvent(QHelpEvent * event, QAbstractItemView * view, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQItemDelegate_HelpEvent(this, event, view, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)) != 0; };
	void timerEvent(QTimerEvent * event) { callbackQItemDelegate_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQItemDelegate_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQItemDelegate_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQItemDelegate_CustomEvent(this, event); };
	void deleteLater() { callbackQItemDelegate_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQItemDelegate_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQItemDelegate_Event(this, e) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQItemDelegate_MetaObject(const_cast<MyQItemDelegate*>(this))); };
};

char QItemDelegate_EventFilter(void* ptr, void* editor, void* event)
{
	return static_cast<QItemDelegate*>(ptr)->eventFilter(static_cast<QObject*>(editor), static_cast<QEvent*>(event));
}

char QItemDelegate_HasClipping(void* ptr)
{
	return static_cast<QItemDelegate*>(ptr)->hasClipping();
}

void QItemDelegate_SetClipping(void* ptr, char clip)
{
	static_cast<QItemDelegate*>(ptr)->setClipping(clip != 0);
}

void* QItemDelegate_NewQItemDelegate(void* parent)
{
	return new MyQItemDelegate(static_cast<QObject*>(parent));
}

void* QItemDelegate_CreateEditor(void* ptr, void* parent, void* option, void* index)
{
	return static_cast<QItemDelegate*>(ptr)->createEditor(static_cast<QWidget*>(parent), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void* QItemDelegate_CreateEditorDefault(void* ptr, void* parent, void* option, void* index)
{
	return static_cast<QItemDelegate*>(ptr)->QItemDelegate::createEditor(static_cast<QWidget*>(parent), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

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, char* text)
{
	static_cast<QItemDelegate*>(ptr)->drawDisplay(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QRect*>(rect), QString(text));
}

void QItemDelegate_DrawDisplayDefault(void* ptr, void* painter, void* option, void* rect, char* text)
{
	static_cast<QItemDelegate*>(ptr)->QItemDelegate::drawDisplay(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QRect*>(rect), QString(text));
}

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_EditorEvent(void* ptr, void* event, void* model, void* option, void* index)
{
	return static_cast<QItemDelegate*>(ptr)->editorEvent(static_cast<QEvent*>(event), static_cast<QAbstractItemModel*>(model), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

char QItemDelegate_EditorEventDefault(void* ptr, void* event, void* model, void* option, void* index)
{
	return static_cast<QItemDelegate*>(ptr)->QItemDelegate::editorEvent(static_cast<QEvent*>(event), static_cast<QAbstractItemModel*>(model), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

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_SetEditorData(void* ptr, void* editor, void* index)
{
	static_cast<QItemDelegate*>(ptr)->setEditorData(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
}

void QItemDelegate_SetEditorDataDefault(void* ptr, void* editor, void* index)
{
	static_cast<QItemDelegate*>(ptr)->QItemDelegate::setEditorData(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
}

void QItemDelegate_SetItemEditorFactory(void* ptr, void* factory)
{
	static_cast<QItemDelegate*>(ptr)->setItemEditorFactory(static_cast<QItemEditorFactory*>(factory));
}

void QItemDelegate_SetModelData(void* ptr, void* editor, void* model, void* index)
{
	static_cast<QItemDelegate*>(ptr)->setModelData(static_cast<QWidget*>(editor), static_cast<QAbstractItemModel*>(model), *static_cast<QModelIndex*>(index));
}

void QItemDelegate_SetModelDataDefault(void* ptr, void* editor, void* model, void* index)
{
	static_cast<QItemDelegate*>(ptr)->QItemDelegate::setModelData(static_cast<QWidget*>(editor), static_cast<QAbstractItemModel*>(model), *static_cast<QModelIndex*>(index));
}

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_UpdateEditorGeometry(void* ptr, void* editor, void* option, void* index)
{
	static_cast<QItemDelegate*>(ptr)->updateEditorGeometry(static_cast<QWidget*>(editor), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QItemDelegate_UpdateEditorGeometryDefault(void* ptr, void* editor, void* option, void* index)
{
	static_cast<QItemDelegate*>(ptr)->QItemDelegate::updateEditorGeometry(static_cast<QWidget*>(editor), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QItemDelegate_DestroyQItemDelegate(void* ptr)
{
	static_cast<QItemDelegate*>(ptr)->~QItemDelegate();
}

void QItemDelegate_DestroyEditor(void* ptr, void* editor, void* index)
{
	static_cast<QItemDelegate*>(ptr)->destroyEditor(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
}

void QItemDelegate_DestroyEditorDefault(void* ptr, void* editor, void* index)
{
	static_cast<QItemDelegate*>(ptr)->QItemDelegate::destroyEditor(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
}

char QItemDelegate_HelpEvent(void* ptr, void* event, void* view, void* option, void* index)
{
	return static_cast<QItemDelegate*>(ptr)->helpEvent(static_cast<QHelpEvent*>(event), static_cast<QAbstractItemView*>(view), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

char QItemDelegate_HelpEventDefault(void* ptr, void* event, void* view, void* option, void* index)
{
	return static_cast<QItemDelegate*>(ptr)->QItemDelegate::helpEvent(static_cast<QHelpEvent*>(event), static_cast<QAbstractItemView*>(view), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QItemDelegate_TimerEvent(void* ptr, void* event)
{
	static_cast<QItemDelegate*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QItemDelegate_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QItemDelegate*>(ptr)->QItemDelegate::timerEvent(static_cast<QTimerEvent*>(event));
}

void QItemDelegate_ChildEvent(void* ptr, void* event)
{
	static_cast<QItemDelegate*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QItemDelegate_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QItemDelegate*>(ptr)->QItemDelegate::childEvent(static_cast<QChildEvent*>(event));
}

void QItemDelegate_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QItemDelegate*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QItemDelegate_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QItemDelegate*>(ptr)->QItemDelegate::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QItemDelegate_CustomEvent(void* ptr, void* event)
{
	static_cast<QItemDelegate*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QItemDelegate_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QItemDelegate*>(ptr)->QItemDelegate::customEvent(static_cast<QEvent*>(event));
}

void QItemDelegate_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QItemDelegate*>(ptr), "deleteLater");
}

void QItemDelegate_DeleteLaterDefault(void* ptr)
{
	static_cast<QItemDelegate*>(ptr)->QItemDelegate::deleteLater();
}

void QItemDelegate_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QItemDelegate*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QItemDelegate_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QItemDelegate*>(ptr)->QItemDelegate::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QItemDelegate_Event(void* ptr, void* e)
{
	return static_cast<QItemDelegate*>(ptr)->event(static_cast<QEvent*>(e));
}

char QItemDelegate_EventDefault(void* ptr, void* e)
{
	return static_cast<QItemDelegate*>(ptr)->QItemDelegate::event(static_cast<QEvent*>(e));
}

void* QItemDelegate_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QItemDelegate*>(ptr)->metaObject());
}

void* QItemDelegate_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QItemDelegate*>(ptr)->QItemDelegate::metaObject());
}

class MyQItemEditorCreatorBase: public QItemEditorCreatorBase
{
public:
	 ~MyQItemEditorCreatorBase() { callbackQItemEditorCreatorBase_DestroyQItemEditorCreatorBase(this); };
	QWidget * createWidget(QWidget * parent) const { return static_cast<QWidget*>(callbackQItemEditorCreatorBase_CreateWidget(const_cast<MyQItemEditorCreatorBase*>(this), parent)); };
	QByteArray valuePropertyName() const { return QByteArray::fromHex(QString(callbackQItemEditorCreatorBase_ValuePropertyName(const_cast<MyQItemEditorCreatorBase*>(this))).toUtf8()); };
};

void QItemEditorCreatorBase_DestroyQItemEditorCreatorBase(void* ptr)
{
	static_cast<QItemEditorCreatorBase*>(ptr)->~QItemEditorCreatorBase();
}

void QItemEditorCreatorBase_DestroyQItemEditorCreatorBaseDefault(void* ptr)
{

}

void* QItemEditorCreatorBase_CreateWidget(void* ptr, void* parent)
{
	return static_cast<QItemEditorCreatorBase*>(ptr)->createWidget(static_cast<QWidget*>(parent));
}

char* QItemEditorCreatorBase_ValuePropertyName(void* ptr)
{
	return const_cast<char*>(static_cast<QItemEditorCreatorBase*>(ptr)->valuePropertyName().toHex().prepend("WHITESPACE").constData()+10);
}

class MyQItemEditorFactory: public QItemEditorFactory
{
public:
	MyQItemEditorFactory() : QItemEditorFactory() {};
	QWidget * createEditor(int userType, QWidget * parent) const { return static_cast<QWidget*>(callbackQItemEditorFactory_CreateEditor(const_cast<MyQItemEditorFactory*>(this), userType, parent)); };
	QByteArray valuePropertyName(int userType) const { return QByteArray::fromHex(QString(callbackQItemEditorFactory_ValuePropertyName(const_cast<MyQItemEditorFactory*>(this), userType)).toUtf8()); };
	 ~MyQItemEditorFactory() { callbackQItemEditorFactory_DestroyQItemEditorFactory(this); };
};

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));
}

char* QItemEditorFactory_ValuePropertyName(void* ptr, int userType)
{
	return const_cast<char*>(static_cast<QItemEditorFactory*>(ptr)->valuePropertyName(userType).toHex().prepend("WHITESPACE").constData()+10);
}

char* QItemEditorFactory_ValuePropertyNameDefault(void* ptr, int userType)
{
	return const_cast<char*>(static_cast<QItemEditorFactory*>(ptr)->QItemEditorFactory::valuePropertyName(userType).toHex().prepend("WHITESPACE").constData()+10);
}

void QItemEditorFactory_DestroyQItemEditorFactory(void* ptr)
{
	static_cast<QItemEditorFactory*>(ptr)->~QItemEditorFactory();
}

void QItemEditorFactory_DestroyQItemEditorFactoryDefault(void* ptr)
{

}

void* QKeyEventTransition_NewQKeyEventTransition2(void* object, long long ty, int key, void* sourceState)
{
	return new QKeyEventTransition(static_cast<QObject*>(object), static_cast<QEvent::Type>(ty), key, static_cast<QState*>(sourceState));
}

void* QKeyEventTransition_NewQKeyEventTransition(void* sourceState)
{
	return new QKeyEventTransition(static_cast<QState*>(sourceState));
}

char QKeyEventTransition_EventTest(void* ptr, void* event)
{
	return static_cast<QKeyEventTransition*>(ptr)->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_OnTransition(void* ptr, void* event)
{
	static_cast<QKeyEventTransition*>(ptr)->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();
}

char QKeyEventTransition_Event(void* ptr, void* e)
{
	return static_cast<QKeyEventTransition*>(ptr)->event(static_cast<QEvent*>(e));
}

char QKeyEventTransition_EventDefault(void* ptr, void* e)
{
	return static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::event(static_cast<QEvent*>(e));
}

void QKeyEventTransition_TimerEvent(void* ptr, void* event)
{
	static_cast<QKeyEventTransition*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QKeyEventTransition_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::timerEvent(static_cast<QTimerEvent*>(event));
}

void QKeyEventTransition_ChildEvent(void* ptr, void* event)
{
	static_cast<QKeyEventTransition*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QKeyEventTransition_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::childEvent(static_cast<QChildEvent*>(event));
}

void QKeyEventTransition_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QKeyEventTransition*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QKeyEventTransition_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QKeyEventTransition_CustomEvent(void* ptr, void* event)
{
	static_cast<QKeyEventTransition*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QKeyEventTransition_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::customEvent(static_cast<QEvent*>(event));
}

void QKeyEventTransition_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeyEventTransition*>(ptr), "deleteLater");
}

void QKeyEventTransition_DeleteLaterDefault(void* ptr)
{
	static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::deleteLater();
}

void QKeyEventTransition_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QKeyEventTransition*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QKeyEventTransition_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QKeyEventTransition_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QKeyEventTransition*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QKeyEventTransition_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QKeyEventTransition_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QKeyEventTransition*>(ptr)->metaObject());
}

void* QKeyEventTransition_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QKeyEventTransition*>(ptr)->QKeyEventTransition::metaObject());
}

class MyQKeySequenceEdit: public QKeySequenceEdit
{
public:
	MyQKeySequenceEdit(QWidget *parent) : QKeySequenceEdit(parent) {};
	MyQKeySequenceEdit(const QKeySequence &keySequence, QWidget *parent) : QKeySequenceEdit(keySequence, parent) {};
	void setKeySequence(const QKeySequence & keySequence) { callbackQKeySequenceEdit_SetKeySequence(this, const_cast<QKeySequence*>(&keySequence)); };
	void clear() { callbackQKeySequenceEdit_Clear(this); };
	void Signal_EditingFinished() { callbackQKeySequenceEdit_EditingFinished(this); };
	void keyPressEvent(QKeyEvent * e) { callbackQKeySequenceEdit_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQKeySequenceEdit_KeyReleaseEvent(this, e); };
	void Signal_KeySequenceChanged(const QKeySequence & keySequence) { callbackQKeySequenceEdit_KeySequenceChanged(this, const_cast<QKeySequence*>(&keySequence)); };
	void actionEvent(QActionEvent * event) { callbackQKeySequenceEdit_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQKeySequenceEdit_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQKeySequenceEdit_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQKeySequenceEdit_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQKeySequenceEdit_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQKeySequenceEdit_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQKeySequenceEdit_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQKeySequenceEdit_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQKeySequenceEdit_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQKeySequenceEdit_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQKeySequenceEdit_MinimumSizeHint(const_cast<MyQKeySequenceEdit*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQKeySequenceEdit_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQKeySequenceEdit_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQKeySequenceEdit_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQKeySequenceEdit_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQKeySequenceEdit_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQKeySequenceEdit_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQKeySequenceEdit_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQKeySequenceEdit_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQKeySequenceEdit_SizeHint(const_cast<MyQKeySequenceEdit*>(this))); };
	void changeEvent(QEvent * event) { callbackQKeySequenceEdit_ChangeEvent(this, event); };
	bool close() { return callbackQKeySequenceEdit_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQKeySequenceEdit_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQKeySequenceEdit_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQKeySequenceEdit_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQKeySequenceEdit_HasHeightForWidth(const_cast<MyQKeySequenceEdit*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQKeySequenceEdit_HeightForWidth(const_cast<MyQKeySequenceEdit*>(this), w); };
	void hide() { callbackQKeySequenceEdit_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQKeySequenceEdit_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQKeySequenceEdit_InputMethodQuery(const_cast<MyQKeySequenceEdit*>(this), query)); };
	void lower() { callbackQKeySequenceEdit_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQKeySequenceEdit_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQKeySequenceEdit_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQKeySequenceEdit_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQKeySequenceEdit_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQKeySequenceEdit_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQKeySequenceEdit_Raise(this); };
	void repaint() { callbackQKeySequenceEdit_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQKeySequenceEdit_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQKeySequenceEdit_SetDisabled(this, disable); };
	void setFocus() { callbackQKeySequenceEdit_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQKeySequenceEdit_SetHidden(this, hidden); };
	void show() { callbackQKeySequenceEdit_Show(this); };
	void showFullScreen() { callbackQKeySequenceEdit_ShowFullScreen(this); };
	void showMaximized() { callbackQKeySequenceEdit_ShowMaximized(this); };
	void showMinimized() { callbackQKeySequenceEdit_ShowMinimized(this); };
	void showNormal() { callbackQKeySequenceEdit_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQKeySequenceEdit_TabletEvent(this, event); };
	void update() { callbackQKeySequenceEdit_Update(this); };
	void updateMicroFocus() { callbackQKeySequenceEdit_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQKeySequenceEdit_WheelEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQKeySequenceEdit_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQKeySequenceEdit_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQKeySequenceEdit_CustomEvent(this, event); };
	void deleteLater() { callbackQKeySequenceEdit_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQKeySequenceEdit_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQKeySequenceEdit_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQKeySequenceEdit_MetaObject(const_cast<MyQKeySequenceEdit*>(this))); };
};

void* QKeySequenceEdit_KeySequence(void* ptr)
{
	return new QKeySequence(static_cast<QKeySequenceEdit*>(ptr)->keySequence());
}

void QKeySequenceEdit_SetKeySequence(void* ptr, void* keySequence)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setKeySequence", Q_ARG(QKeySequence, *static_cast<QKeySequence*>(keySequence)));
}

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_ConnectEditingFinished(void* ptr)
{
	QObject::connect(static_cast<QKeySequenceEdit*>(ptr), static_cast<void (QKeySequenceEdit::*)()>(&QKeySequenceEdit::editingFinished), static_cast<MyQKeySequenceEdit*>(ptr), static_cast<void (MyQKeySequenceEdit::*)()>(&MyQKeySequenceEdit::Signal_EditingFinished));
}

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();
}

char QKeySequenceEdit_Event(void* ptr, void* e)
{
	return static_cast<QKeySequenceEdit*>(ptr)->event(static_cast<QEvent*>(e));
}

void QKeySequenceEdit_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QKeySequenceEdit*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QKeySequenceEdit_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QKeySequenceEdit_KeyReleaseEvent(void* ptr, void* e)
{
	static_cast<QKeySequenceEdit*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QKeySequenceEdit_KeyReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QKeySequenceEdit_ConnectKeySequenceChanged(void* ptr)
{
	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));
}

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_TimerEvent(void* ptr, void* e)
{
	static_cast<QKeySequenceEdit*>(ptr)->timerEvent(static_cast<QTimerEvent*>(e));
}

void QKeySequenceEdit_DestroyQKeySequenceEdit(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->~QKeySequenceEdit();
}

void QKeySequenceEdit_ActionEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QKeySequenceEdit_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::actionEvent(static_cast<QActionEvent*>(event));
}

void QKeySequenceEdit_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QKeySequenceEdit_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QKeySequenceEdit_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QKeySequenceEdit_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QKeySequenceEdit_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QKeySequenceEdit_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QKeySequenceEdit_DropEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QKeySequenceEdit_DropEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::dropEvent(static_cast<QDropEvent*>(event));
}

void QKeySequenceEdit_EnterEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QKeySequenceEdit_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::enterEvent(static_cast<QEvent*>(event));
}

void QKeySequenceEdit_FocusInEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QKeySequenceEdit_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QKeySequenceEdit_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QKeySequenceEdit_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QKeySequenceEdit_HideEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QKeySequenceEdit_HideEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::hideEvent(static_cast<QHideEvent*>(event));
}

void QKeySequenceEdit_LeaveEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QKeySequenceEdit_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::leaveEvent(static_cast<QEvent*>(event));
}

void* QKeySequenceEdit_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QKeySequenceEdit*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QKeySequenceEdit_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QKeySequenceEdit_MoveEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QKeySequenceEdit_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::moveEvent(static_cast<QMoveEvent*>(event));
}

void QKeySequenceEdit_PaintEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QKeySequenceEdit_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::paintEvent(static_cast<QPaintEvent*>(event));
}

void QKeySequenceEdit_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QKeySequenceEdit_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setEnabled(vbo != 0);
}

void QKeySequenceEdit_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QKeySequenceEdit_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setStyleSheet(QString(styleSheet));
}

void QKeySequenceEdit_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QKeySequenceEdit_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setVisible(visible != 0);
}

void QKeySequenceEdit_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QKeySequenceEdit_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setWindowModified(vbo != 0);
}

void QKeySequenceEdit_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QKeySequenceEdit_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setWindowTitle(QString(vqs));
}

void QKeySequenceEdit_ShowEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QKeySequenceEdit_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::showEvent(static_cast<QShowEvent*>(event));
}

void* QKeySequenceEdit_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QKeySequenceEdit*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QKeySequenceEdit_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QKeySequenceEdit_ChangeEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QKeySequenceEdit_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::changeEvent(static_cast<QEvent*>(event));
}

char QKeySequenceEdit_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QKeySequenceEdit_CloseDefault(void* ptr)
{
	return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::close();
}

void QKeySequenceEdit_CloseEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QKeySequenceEdit_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::closeEvent(static_cast<QCloseEvent*>(event));
}

void QKeySequenceEdit_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QKeySequenceEdit_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QKeySequenceEdit_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QKeySequenceEdit*>(ptr)->focusNextPrevChild(next != 0);
}

char QKeySequenceEdit_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::focusNextPrevChild(next != 0);
}

char QKeySequenceEdit_HasHeightForWidth(void* ptr)
{
	return static_cast<QKeySequenceEdit*>(ptr)->hasHeightForWidth();
}

char QKeySequenceEdit_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::hasHeightForWidth();
}

int QKeySequenceEdit_HeightForWidth(void* ptr, int w)
{
	return static_cast<QKeySequenceEdit*>(ptr)->heightForWidth(w);
}

int QKeySequenceEdit_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::heightForWidth(w);
}

void QKeySequenceEdit_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "hide");
}

void QKeySequenceEdit_HideDefault(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::hide();
}

void QKeySequenceEdit_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QKeySequenceEdit_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QKeySequenceEdit_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QKeySequenceEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QKeySequenceEdit_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QKeySequenceEdit_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "lower");
}

void QKeySequenceEdit_LowerDefault(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::lower();
}

void QKeySequenceEdit_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QKeySequenceEdit_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QKeySequenceEdit_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QKeySequenceEdit_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QKeySequenceEdit_MousePressEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QKeySequenceEdit_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QKeySequenceEdit_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QKeySequenceEdit_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QKeySequenceEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QKeySequenceEdit*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QKeySequenceEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QKeySequenceEdit_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "raise");
}

void QKeySequenceEdit_RaiseDefault(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::raise();
}

void QKeySequenceEdit_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "repaint");
}

void QKeySequenceEdit_RepaintDefault(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::repaint();
}

void QKeySequenceEdit_ResizeEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QKeySequenceEdit_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QKeySequenceEdit_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QKeySequenceEdit_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setDisabled(disable != 0);
}

void QKeySequenceEdit_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setFocus");
}

void QKeySequenceEdit_SetFocus2Default(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setFocus();
}

void QKeySequenceEdit_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QKeySequenceEdit_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setHidden(hidden != 0);
}

void QKeySequenceEdit_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "show");
}

void QKeySequenceEdit_ShowDefault(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::show();
}

void QKeySequenceEdit_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "showFullScreen");
}

void QKeySequenceEdit_ShowFullScreenDefault(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::showFullScreen();
}

void QKeySequenceEdit_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "showMaximized");
}

void QKeySequenceEdit_ShowMaximizedDefault(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::showMaximized();
}

void QKeySequenceEdit_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "showMinimized");
}

void QKeySequenceEdit_ShowMinimizedDefault(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::showMinimized();
}

void QKeySequenceEdit_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "showNormal");
}

void QKeySequenceEdit_ShowNormalDefault(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::showNormal();
}

void QKeySequenceEdit_TabletEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QKeySequenceEdit_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QKeySequenceEdit_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "update");
}

void QKeySequenceEdit_UpdateDefault(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::update();
}

void QKeySequenceEdit_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "updateMicroFocus");
}

void QKeySequenceEdit_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::updateMicroFocus();
}

void QKeySequenceEdit_WheelEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QKeySequenceEdit_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QKeySequenceEdit_ChildEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QKeySequenceEdit_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::childEvent(static_cast<QChildEvent*>(event));
}

void QKeySequenceEdit_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QKeySequenceEdit*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QKeySequenceEdit_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QKeySequenceEdit_CustomEvent(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QKeySequenceEdit_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::customEvent(static_cast<QEvent*>(event));
}

void QKeySequenceEdit_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "deleteLater");
}

void QKeySequenceEdit_DeleteLaterDefault(void* ptr)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::deleteLater();
}

void QKeySequenceEdit_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QKeySequenceEdit*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QKeySequenceEdit_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QKeySequenceEdit_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QKeySequenceEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QKeySequenceEdit_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QKeySequenceEdit_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QKeySequenceEdit*>(ptr)->metaObject());
}

void* QKeySequenceEdit_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::metaObject());
}

class MyQLCDNumber: public QLCDNumber
{
public:
	MyQLCDNumber(QWidget *parent) : QLCDNumber(parent) {};
	MyQLCDNumber(uint numDigits, QWidget *parent) : QLCDNumber(numDigits, parent) {};
	void setSmallDecimalPoint(bool vbo) { callbackQLCDNumber_SetSmallDecimalPoint(this, vbo); };
	void display(const QString & s) { callbackQLCDNumber_Display(this, const_cast<char*>(s.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void display(double num) { callbackQLCDNumber_Display3(this, num); };
	void display(int num) { callbackQLCDNumber_Display2(this, num); };
	void Signal_Overflow() { callbackQLCDNumber_Overflow(this); };
	void paintEvent(QPaintEvent * vqp) { callbackQLCDNumber_PaintEvent(this, vqp); };
	void setBinMode() { callbackQLCDNumber_SetBinMode(this); };
	void setDecMode() { callbackQLCDNumber_SetDecMode(this); };
	void setHexMode() { callbackQLCDNumber_SetHexMode(this); };
	void setOctMode() { callbackQLCDNumber_SetOctMode(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQLCDNumber_SizeHint(const_cast<MyQLCDNumber*>(this))); };
	void changeEvent(QEvent * ev) { callbackQLCDNumber_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQLCDNumber_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQLCDNumber_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQLCDNumber_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQLCDNumber_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQLCDNumber_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQLCDNumber_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQLCDNumber_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQLCDNumber_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQLCDNumber_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQLCDNumber_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQLCDNumber_MinimumSizeHint(const_cast<MyQLCDNumber*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQLCDNumber_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQLCDNumber_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQLCDNumber_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQLCDNumber_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQLCDNumber_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQLCDNumber_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQLCDNumber_ShowEvent(this, event); };
	bool close() { return callbackQLCDNumber_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQLCDNumber_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQLCDNumber_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQLCDNumber_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQLCDNumber_HasHeightForWidth(const_cast<MyQLCDNumber*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQLCDNumber_HeightForWidth(const_cast<MyQLCDNumber*>(this), w); };
	void hide() { callbackQLCDNumber_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQLCDNumber_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQLCDNumber_InputMethodQuery(const_cast<MyQLCDNumber*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQLCDNumber_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQLCDNumber_KeyReleaseEvent(this, event); };
	void lower() { callbackQLCDNumber_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQLCDNumber_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQLCDNumber_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQLCDNumber_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQLCDNumber_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQLCDNumber_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQLCDNumber_Raise(this); };
	void repaint() { callbackQLCDNumber_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQLCDNumber_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQLCDNumber_SetDisabled(this, disable); };
	void setFocus() { callbackQLCDNumber_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQLCDNumber_SetHidden(this, hidden); };
	void show() { callbackQLCDNumber_Show(this); };
	void showFullScreen() { callbackQLCDNumber_ShowFullScreen(this); };
	void showMaximized() { callbackQLCDNumber_ShowMaximized(this); };
	void showMinimized() { callbackQLCDNumber_ShowMinimized(this); };
	void showNormal() { callbackQLCDNumber_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQLCDNumber_TabletEvent(this, event); };
	void update() { callbackQLCDNumber_Update(this); };
	void updateMicroFocus() { callbackQLCDNumber_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQLCDNumber_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQLCDNumber_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQLCDNumber_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQLCDNumber_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQLCDNumber_CustomEvent(this, event); };
	void deleteLater() { callbackQLCDNumber_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQLCDNumber_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQLCDNumber_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLCDNumber_MetaObject(const_cast<MyQLCDNumber*>(this))); };
};

int QLCDNumber_IntValue(void* ptr)
{
	return static_cast<QLCDNumber*>(ptr)->intValue();
}

long long QLCDNumber_Mode(void* ptr)
{
	return static_cast<QLCDNumber*>(ptr)->mode();
}

long long QLCDNumber_SegmentStyle(void* ptr)
{
	return static_cast<QLCDNumber*>(ptr)->segmentStyle();
}

void QLCDNumber_SetMode(void* ptr, long long vmo)
{
	static_cast<QLCDNumber*>(ptr)->setMode(static_cast<QLCDNumber::Mode>(vmo));
}

void QLCDNumber_SetSegmentStyle(void* ptr, long long vse)
{
	static_cast<QLCDNumber*>(ptr)->setSegmentStyle(static_cast<QLCDNumber::SegmentStyle>(vse));
}

void QLCDNumber_SetSmallDecimalPoint(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setSmallDecimalPoint", Q_ARG(bool, 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_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, char* s)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "display", Q_ARG(QString, QString(s)));
}

void QLCDNumber_Display3(void* ptr, double num)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "display", Q_ARG(double, num));
}

void QLCDNumber_Display2(void* ptr, int num)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "display", Q_ARG(int, num));
}

char QLCDNumber_Event(void* ptr, void* e)
{
	return static_cast<QLCDNumber*>(ptr)->event(static_cast<QEvent*>(e));
}

void QLCDNumber_ConnectOverflow(void* ptr)
{
	QObject::connect(static_cast<QLCDNumber*>(ptr), static_cast<void (QLCDNumber::*)()>(&QLCDNumber::overflow), static_cast<MyQLCDNumber*>(ptr), static_cast<void (MyQLCDNumber::*)()>(&MyQLCDNumber::Signal_Overflow));
}

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();
}

void QLCDNumber_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QLCDNumber*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QLCDNumber_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QLCDNumber_SetBinMode(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setBinMode");
}

void QLCDNumber_SetDecMode(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "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_SetOctMode(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setOctMode");
}

void* QLCDNumber_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLCDNumber*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QLCDNumber_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLCDNumber*>(ptr)->QLCDNumber::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QLCDNumber_DestroyQLCDNumber(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->~QLCDNumber();
}

void QLCDNumber_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QLCDNumber*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QLCDNumber_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::changeEvent(static_cast<QEvent*>(ev));
}

void QLCDNumber_ActionEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QLCDNumber_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::actionEvent(static_cast<QActionEvent*>(event));
}

void QLCDNumber_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QLCDNumber_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QLCDNumber_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QLCDNumber_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QLCDNumber_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QLCDNumber_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QLCDNumber_DropEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QLCDNumber_DropEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::dropEvent(static_cast<QDropEvent*>(event));
}

void QLCDNumber_EnterEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QLCDNumber_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::enterEvent(static_cast<QEvent*>(event));
}

void QLCDNumber_FocusInEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QLCDNumber_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QLCDNumber_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QLCDNumber_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QLCDNumber_HideEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QLCDNumber_HideEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::hideEvent(static_cast<QHideEvent*>(event));
}

void QLCDNumber_LeaveEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QLCDNumber_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::leaveEvent(static_cast<QEvent*>(event));
}

void* QLCDNumber_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLCDNumber*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QLCDNumber_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLCDNumber*>(ptr)->QLCDNumber::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QLCDNumber_MoveEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QLCDNumber_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::moveEvent(static_cast<QMoveEvent*>(event));
}

void QLCDNumber_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QLCDNumber_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::setEnabled(vbo != 0);
}

void QLCDNumber_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QLCDNumber_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::setStyleSheet(QString(styleSheet));
}

void QLCDNumber_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QLCDNumber_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::setVisible(visible != 0);
}

void QLCDNumber_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QLCDNumber_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::setWindowModified(vbo != 0);
}

void QLCDNumber_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QLCDNumber_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::setWindowTitle(QString(vqs));
}

void QLCDNumber_ShowEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QLCDNumber_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::showEvent(static_cast<QShowEvent*>(event));
}

char QLCDNumber_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QLCDNumber_CloseDefault(void* ptr)
{
	return static_cast<QLCDNumber*>(ptr)->QLCDNumber::close();
}

void QLCDNumber_CloseEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QLCDNumber_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::closeEvent(static_cast<QCloseEvent*>(event));
}

void QLCDNumber_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QLCDNumber_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QLCDNumber_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QLCDNumber*>(ptr)->focusNextPrevChild(next != 0);
}

char QLCDNumber_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QLCDNumber*>(ptr)->QLCDNumber::focusNextPrevChild(next != 0);
}

char QLCDNumber_HasHeightForWidth(void* ptr)
{
	return static_cast<QLCDNumber*>(ptr)->hasHeightForWidth();
}

char QLCDNumber_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QLCDNumber*>(ptr)->QLCDNumber::hasHeightForWidth();
}

int QLCDNumber_HeightForWidth(void* ptr, int w)
{
	return static_cast<QLCDNumber*>(ptr)->heightForWidth(w);
}

int QLCDNumber_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QLCDNumber*>(ptr)->QLCDNumber::heightForWidth(w);
}

void QLCDNumber_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "hide");
}

void QLCDNumber_HideDefault(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::hide();
}

void QLCDNumber_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QLCDNumber_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QLCDNumber_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QLCDNumber*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QLCDNumber_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QLCDNumber*>(ptr)->QLCDNumber::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QLCDNumber_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QLCDNumber_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QLCDNumber_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QLCDNumber_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QLCDNumber_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "lower");
}

void QLCDNumber_LowerDefault(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::lower();
}

void QLCDNumber_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QLCDNumber_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QLCDNumber_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QLCDNumber_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QLCDNumber_MousePressEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QLCDNumber_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QLCDNumber_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QLCDNumber_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QLCDNumber_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QLCDNumber*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QLCDNumber_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QLCDNumber*>(ptr)->QLCDNumber::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QLCDNumber_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "raise");
}

void QLCDNumber_RaiseDefault(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::raise();
}

void QLCDNumber_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "repaint");
}

void QLCDNumber_RepaintDefault(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::repaint();
}

void QLCDNumber_ResizeEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QLCDNumber_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QLCDNumber_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QLCDNumber_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::setDisabled(disable != 0);
}

void QLCDNumber_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setFocus");
}

void QLCDNumber_SetFocus2Default(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::setFocus();
}

void QLCDNumber_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QLCDNumber_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::setHidden(hidden != 0);
}

void QLCDNumber_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "show");
}

void QLCDNumber_ShowDefault(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::show();
}

void QLCDNumber_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "showFullScreen");
}

void QLCDNumber_ShowFullScreenDefault(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::showFullScreen();
}

void QLCDNumber_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "showMaximized");
}

void QLCDNumber_ShowMaximizedDefault(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::showMaximized();
}

void QLCDNumber_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "showMinimized");
}

void QLCDNumber_ShowMinimizedDefault(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::showMinimized();
}

void QLCDNumber_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "showNormal");
}

void QLCDNumber_ShowNormalDefault(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::showNormal();
}

void QLCDNumber_TabletEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QLCDNumber_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QLCDNumber_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "update");
}

void QLCDNumber_UpdateDefault(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::update();
}

void QLCDNumber_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "updateMicroFocus");
}

void QLCDNumber_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::updateMicroFocus();
}

void QLCDNumber_WheelEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QLCDNumber_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QLCDNumber_TimerEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QLCDNumber_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::timerEvent(static_cast<QTimerEvent*>(event));
}

void QLCDNumber_ChildEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QLCDNumber_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::childEvent(static_cast<QChildEvent*>(event));
}

void QLCDNumber_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QLCDNumber*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QLCDNumber_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QLCDNumber_CustomEvent(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QLCDNumber_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::customEvent(static_cast<QEvent*>(event));
}

void QLCDNumber_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "deleteLater");
}

void QLCDNumber_DeleteLaterDefault(void* ptr)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::deleteLater();
}

void QLCDNumber_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QLCDNumber*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QLCDNumber_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QLCDNumber*>(ptr)->QLCDNumber::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QLCDNumber_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QLCDNumber*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QLCDNumber_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QLCDNumber*>(ptr)->QLCDNumber::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QLCDNumber_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QLCDNumber*>(ptr)->metaObject());
}

void* QLCDNumber_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QLCDNumber*>(ptr)->QLCDNumber::metaObject());
}

class MyQLabel: public QLabel
{
public:
	MyQLabel(QWidget *parent, Qt::WindowFlags f) : QLabel(parent, f) {};
	MyQLabel(const QString &text, QWidget *parent, Qt::WindowFlags f) : QLabel(text, parent, f) {};
	void setPixmap(const QPixmap & vqp) { callbackQLabel_SetPixmap(this, const_cast<QPixmap*>(&vqp)); };
	void setText(const QString & vqs) { callbackQLabel_SetText(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void changeEvent(QEvent * ev) { callbackQLabel_ChangeEvent(this, ev); };
	void clear() { callbackQLabel_Clear(this); };
	void contextMenuEvent(QContextMenuEvent * ev) { callbackQLabel_ContextMenuEvent(this, ev); };
	void focusInEvent(QFocusEvent * ev) { callbackQLabel_FocusInEvent(this, ev); };
	bool focusNextPrevChild(bool next) { return callbackQLabel_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * ev) { callbackQLabel_FocusOutEvent(this, ev); };
	int heightForWidth(int w) const { return callbackQLabel_HeightForWidth(const_cast<MyQLabel*>(this), w); };
	void keyPressEvent(QKeyEvent * ev) { callbackQLabel_KeyPressEvent(this, ev); };
	void Signal_LinkActivated(const QString & link) { callbackQLabel_LinkActivated(this, const_cast<char*>(link.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_LinkHovered(const QString & link) { callbackQLabel_LinkHovered(this, const_cast<char*>(link.toUtf8().prepend("WHITESPACE").constData()+10)); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQLabel_MinimumSizeHint(const_cast<MyQLabel*>(this))); };
	void mouseMoveEvent(QMouseEvent * ev) { callbackQLabel_MouseMoveEvent(this, ev); };
	void mousePressEvent(QMouseEvent * ev) { callbackQLabel_MousePressEvent(this, ev); };
	void mouseReleaseEvent(QMouseEvent * ev) { callbackQLabel_MouseReleaseEvent(this, ev); };
	void paintEvent(QPaintEvent * vqp) { callbackQLabel_PaintEvent(this, vqp); };
	void setMovie(QMovie * movie) { callbackQLabel_SetMovie(this, movie); };
	void setNum(double num) { callbackQLabel_SetNum2(this, num); };
	void setNum(int num) { callbackQLabel_SetNum(this, num); };
	void setPicture(const QPicture & picture) { callbackQLabel_SetPicture(this, const_cast<QPicture*>(&picture)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQLabel_SizeHint(const_cast<MyQLabel*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQLabel_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQLabel_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQLabel_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQLabel_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQLabel_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQLabel_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQLabel_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQLabel_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQLabel_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQLabel_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQLabel_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQLabel_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQLabel_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQLabel_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQLabel_ShowEvent(this, event); };
	bool close() { return callbackQLabel_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQLabel_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQLabel_HasHeightForWidth(const_cast<MyQLabel*>(this)) != 0; };
	void hide() { callbackQLabel_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQLabel_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQLabel_InputMethodQuery(const_cast<MyQLabel*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQLabel_KeyReleaseEvent(this, event); };
	void lower() { callbackQLabel_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQLabel_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQLabel_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQLabel_Raise(this); };
	void repaint() { callbackQLabel_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQLabel_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQLabel_SetDisabled(this, disable); };
	void setFocus() { callbackQLabel_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQLabel_SetHidden(this, hidden); };
	void show() { callbackQLabel_Show(this); };
	void showFullScreen() { callbackQLabel_ShowFullScreen(this); };
	void showMaximized() { callbackQLabel_ShowMaximized(this); };
	void showMinimized() { callbackQLabel_ShowMinimized(this); };
	void showNormal() { callbackQLabel_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQLabel_TabletEvent(this, event); };
	void update() { callbackQLabel_Update(this); };
	void updateMicroFocus() { callbackQLabel_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQLabel_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQLabel_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQLabel_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQLabel_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQLabel_CustomEvent(this, event); };
	void deleteLater() { callbackQLabel_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQLabel_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQLabel_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLabel_MetaObject(const_cast<MyQLabel*>(this))); };
};

long long QLabel_Alignment(void* ptr)
{
	return static_cast<QLabel*>(ptr)->alignment();
}

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();
}

int QLabel_Margin(void* ptr)
{
	return static_cast<QLabel*>(ptr)->margin();
}

char QLabel_OpenExternalLinks(void* ptr)
{
	return static_cast<QLabel*>(ptr)->openExternalLinks();
}

void* QLabel_Pixmap(void* ptr)
{
	return const_cast<QPixmap*>(static_cast<QLabel*>(ptr)->pixmap());
}

char* QLabel_SelectedText(void* ptr)
{
	return const_cast<char*>(static_cast<QLabel*>(ptr)->selectedText().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QLabel_SetAlignment(void* ptr, long long vqt)
{
	static_cast<QLabel*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(vqt));
}

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_SetOpenExternalLinks(void* ptr, char open)
{
	static_cast<QLabel*>(ptr)->setOpenExternalLinks(open != 0);
}

void QLabel_SetPixmap(void* ptr, void* vqp)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setPixmap", Q_ARG(QPixmap, *static_cast<QPixmap*>(vqp)));
}

void QLabel_SetScaledContents(void* ptr, char vbo)
{
	static_cast<QLabel*>(ptr)->setScaledContents(vbo != 0);
}

void QLabel_SetText(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setText", Q_ARG(QString, QString(vqs)));
}

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);
}

char* QLabel_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QLabel*>(ptr)->text().toUtf8().prepend("WHITESPACE").constData()+10);
}

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_NewQLabel(void* parent, long long f)
{
	return new MyQLabel(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
}

void* QLabel_NewQLabel2(char* text, void* parent, long long f)
{
	return new MyQLabel(QString(text), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
}

void* QLabel_Buddy(void* ptr)
{
	return static_cast<QLabel*>(ptr)->buddy();
}

void QLabel_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QLabel_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->QLabel::changeEvent(static_cast<QEvent*>(ev));
}

void QLabel_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "clear");
}

void QLabel_ContextMenuEvent(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(ev));
}

void QLabel_ContextMenuEventDefault(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->QLabel::contextMenuEvent(static_cast<QContextMenuEvent*>(ev));
}

char QLabel_Event(void* ptr, void* e)
{
	return static_cast<QLabel*>(ptr)->event(static_cast<QEvent*>(e));
}

void QLabel_FocusInEvent(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(ev));
}

void QLabel_FocusInEventDefault(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->QLabel::focusInEvent(static_cast<QFocusEvent*>(ev));
}

char QLabel_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QLabel*>(ptr)->focusNextPrevChild(next != 0);
}

char QLabel_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QLabel*>(ptr)->QLabel::focusNextPrevChild(next != 0);
}

void QLabel_FocusOutEvent(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(ev));
}

void QLabel_FocusOutEventDefault(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->QLabel::focusOutEvent(static_cast<QFocusEvent*>(ev));
}

int QLabel_HeightForWidth(void* ptr, int w)
{
	return static_cast<QLabel*>(ptr)->heightForWidth(w);
}

int QLabel_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QLabel*>(ptr)->QLabel::heightForWidth(w);
}

void QLabel_KeyPressEvent(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(ev));
}

void QLabel_KeyPressEventDefault(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->QLabel::keyPressEvent(static_cast<QKeyEvent*>(ev));
}

void QLabel_ConnectLinkActivated(void* ptr)
{
	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));
}

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, char* link)
{
	static_cast<QLabel*>(ptr)->linkActivated(QString(link));
}

void QLabel_ConnectLinkHovered(void* ptr)
{
	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));
}

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, char* link)
{
	static_cast<QLabel*>(ptr)->linkHovered(QString(link));
}

void* QLabel_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLabel*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QLabel_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLabel*>(ptr)->QLabel::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QLabel_MouseMoveEvent(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(ev));
}

void QLabel_MouseMoveEventDefault(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->QLabel::mouseMoveEvent(static_cast<QMouseEvent*>(ev));
}

void QLabel_MousePressEvent(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(ev));
}

void QLabel_MousePressEventDefault(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->QLabel::mousePressEvent(static_cast<QMouseEvent*>(ev));
}

void QLabel_MouseReleaseEvent(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
}

void QLabel_MouseReleaseEventDefault(void* ptr, void* ev)
{
	static_cast<QLabel*>(ptr)->QLabel::mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
}

void* QLabel_Movie(void* ptr)
{
	return static_cast<QLabel*>(ptr)->movie();
}

void QLabel_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QLabel*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QLabel_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QLabel*>(ptr)->QLabel::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void* QLabel_Picture(void* ptr)
{
	return const_cast<QPicture*>(static_cast<QLabel*>(ptr)->picture());
}

int QLabel_SelectionStart(void* ptr)
{
	return static_cast<QLabel*>(ptr)->selectionStart();
}

void QLabel_SetBuddy(void* ptr, void* buddy)
{
	static_cast<QLabel*>(ptr)->setBuddy(static_cast<QWidget*>(buddy));
}

void QLabel_SetMovie(void* ptr, void* movie)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setMovie", Q_ARG(QMovie*, static_cast<QMovie*>(movie)));
}

void QLabel_SetNum2(void* ptr, double num)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setNum", Q_ARG(double, num));
}

void QLabel_SetNum(void* ptr, int num)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setNum", Q_ARG(int, num));
}

void QLabel_SetPicture(void* ptr, void* picture)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setPicture", Q_ARG(QPicture, *static_cast<QPicture*>(picture)));
}

void QLabel_SetSelection(void* ptr, int start, int length)
{
	static_cast<QLabel*>(ptr)->setSelection(start, length);
}

void* QLabel_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLabel*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QLabel_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLabel*>(ptr)->QLabel::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QLabel_DestroyQLabel(void* ptr)
{
	static_cast<QLabel*>(ptr)->~QLabel();
}

void QLabel_ActionEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QLabel_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::actionEvent(static_cast<QActionEvent*>(event));
}

void QLabel_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QLabel_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QLabel_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QLabel_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QLabel_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QLabel_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QLabel_DropEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QLabel_DropEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::dropEvent(static_cast<QDropEvent*>(event));
}

void QLabel_EnterEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QLabel_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::enterEvent(static_cast<QEvent*>(event));
}

void QLabel_HideEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QLabel_HideEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::hideEvent(static_cast<QHideEvent*>(event));
}

void QLabel_LeaveEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QLabel_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::leaveEvent(static_cast<QEvent*>(event));
}

void QLabel_MoveEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QLabel_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::moveEvent(static_cast<QMoveEvent*>(event));
}

void QLabel_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QLabel_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QLabel*>(ptr)->QLabel::setEnabled(vbo != 0);
}

void QLabel_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QLabel_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QLabel*>(ptr)->QLabel::setStyleSheet(QString(styleSheet));
}

void QLabel_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QLabel_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QLabel*>(ptr)->QLabel::setVisible(visible != 0);
}

void QLabel_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QLabel_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QLabel*>(ptr)->QLabel::setWindowModified(vbo != 0);
}

void QLabel_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QLabel_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QLabel*>(ptr)->QLabel::setWindowTitle(QString(vqs));
}

void QLabel_ShowEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QLabel_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::showEvent(static_cast<QShowEvent*>(event));
}

char QLabel_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QLabel_CloseDefault(void* ptr)
{
	return static_cast<QLabel*>(ptr)->QLabel::close();
}

void QLabel_CloseEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QLabel_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::closeEvent(static_cast<QCloseEvent*>(event));
}

char QLabel_HasHeightForWidth(void* ptr)
{
	return static_cast<QLabel*>(ptr)->hasHeightForWidth();
}

char QLabel_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QLabel*>(ptr)->QLabel::hasHeightForWidth();
}

void QLabel_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "hide");
}

void QLabel_HideDefault(void* ptr)
{
	static_cast<QLabel*>(ptr)->QLabel::hide();
}

void QLabel_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QLabel_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QLabel_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QLabel*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QLabel_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QLabel*>(ptr)->QLabel::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QLabel_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QLabel_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QLabel_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "lower");
}

void QLabel_LowerDefault(void* ptr)
{
	static_cast<QLabel*>(ptr)->QLabel::lower();
}

void QLabel_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QLabel_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QLabel_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QLabel*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QLabel_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QLabel*>(ptr)->QLabel::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QLabel_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "raise");
}

void QLabel_RaiseDefault(void* ptr)
{
	static_cast<QLabel*>(ptr)->QLabel::raise();
}

void QLabel_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "repaint");
}

void QLabel_RepaintDefault(void* ptr)
{
	static_cast<QLabel*>(ptr)->QLabel::repaint();
}

void QLabel_ResizeEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QLabel_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QLabel_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QLabel_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QLabel*>(ptr)->QLabel::setDisabled(disable != 0);
}

void QLabel_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setFocus");
}

void QLabel_SetFocus2Default(void* ptr)
{
	static_cast<QLabel*>(ptr)->QLabel::setFocus();
}

void QLabel_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QLabel_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QLabel*>(ptr)->QLabel::setHidden(hidden != 0);
}

void QLabel_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "show");
}

void QLabel_ShowDefault(void* ptr)
{
	static_cast<QLabel*>(ptr)->QLabel::show();
}

void QLabel_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "showFullScreen");
}

void QLabel_ShowFullScreenDefault(void* ptr)
{
	static_cast<QLabel*>(ptr)->QLabel::showFullScreen();
}

void QLabel_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "showMaximized");
}

void QLabel_ShowMaximizedDefault(void* ptr)
{
	static_cast<QLabel*>(ptr)->QLabel::showMaximized();
}

void QLabel_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "showMinimized");
}

void QLabel_ShowMinimizedDefault(void* ptr)
{
	static_cast<QLabel*>(ptr)->QLabel::showMinimized();
}

void QLabel_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "showNormal");
}

void QLabel_ShowNormalDefault(void* ptr)
{
	static_cast<QLabel*>(ptr)->QLabel::showNormal();
}

void QLabel_TabletEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QLabel_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QLabel_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "update");
}

void QLabel_UpdateDefault(void* ptr)
{
	static_cast<QLabel*>(ptr)->QLabel::update();
}

void QLabel_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "updateMicroFocus");
}

void QLabel_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QLabel*>(ptr)->QLabel::updateMicroFocus();
}

void QLabel_WheelEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QLabel_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QLabel_TimerEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QLabel_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::timerEvent(static_cast<QTimerEvent*>(event));
}

void QLabel_ChildEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QLabel_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::childEvent(static_cast<QChildEvent*>(event));
}

void QLabel_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QLabel*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QLabel_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QLabel*>(ptr)->QLabel::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QLabel_CustomEvent(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QLabel_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QLabel*>(ptr)->QLabel::customEvent(static_cast<QEvent*>(event));
}

void QLabel_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "deleteLater");
}

void QLabel_DeleteLaterDefault(void* ptr)
{
	static_cast<QLabel*>(ptr)->QLabel::deleteLater();
}

void QLabel_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QLabel*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QLabel_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QLabel*>(ptr)->QLabel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QLabel_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QLabel*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QLabel_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QLabel*>(ptr)->QLabel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QLabel_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QLabel*>(ptr)->metaObject());
}

void* QLabel_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QLabel*>(ptr)->QLabel::metaObject());
}

class MyQLayout: public QLayout
{
public:
	MyQLayout() : QLayout() {};
	MyQLayout(QWidget *parent) : QLayout(parent) {};
	void addItem(QLayoutItem * item) { callbackQLayout_AddItem(this, item); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayout_ControlTypes(const_cast<MyQLayout*>(this))); };
	int count() const { return callbackQLayout_Count(const_cast<MyQLayout*>(this)); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQLayout_ExpandingDirections(const_cast<MyQLayout*>(this))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQLayout_Geometry(const_cast<MyQLayout*>(this))); };
	int indexOf(QWidget * widget) const { return callbackQLayout_IndexOf(const_cast<MyQLayout*>(this), widget); };
	void invalidate() { callbackQLayout_Invalidate(this); };
	bool isEmpty() const { return callbackQLayout_IsEmpty(const_cast<MyQLayout*>(this)) != 0; };
	QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQLayout_ItemAt(const_cast<MyQLayout*>(this), index)); };
	QLayout * layout() { return static_cast<QLayout*>(callbackQLayout_Layout(this)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQLayout_MaximumSize(const_cast<MyQLayout*>(this))); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQLayout_MinimumSize(const_cast<MyQLayout*>(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 timerEvent(QTimerEvent * event) { callbackQLayout_TimerEvent(this, event); };
	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 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<MyQLayout*>(this))); };
	bool hasHeightForWidth() const { return callbackQLayout_HasHeightForWidth(const_cast<MyQLayout*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQLayout_HeightForWidth(const_cast<MyQLayout*>(this), w); };
	int minimumHeightForWidth(int w) const { return callbackQLayout_MinimumHeightForWidth(const_cast<MyQLayout*>(this), w); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQLayout_SizeHint(const_cast<MyQLayout*>(this))); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayout_SpacerItem(this)); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQLayout_Widget(this)); };
};

void QLayout_SetSizeConstraint(void* ptr, long long vsi)
{
	static_cast<QLayout*>(ptr)->setSizeConstraint(static_cast<QLayout::SizeConstraint>(vsi));
}

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_NewQLayout2()
{
	return new MyQLayout();
}

void* QLayout_NewQLayout(void* parent)
{
	return new MyQLayout(static_cast<QWidget*>(parent));
}

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)
{
	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_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()); });
}

long long QLayout_ControlTypes(void* ptr)
{
	return static_cast<QLayout*>(ptr)->controlTypes();
}

long long QLayout_ControlTypesDefault(void* ptr)
{
	return static_cast<QLayout*>(ptr)->QLayout::controlTypes();
}

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)
{
	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)
{
	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)
{
	return static_cast<QLayout*>(ptr)->QLayout::indexOf(static_cast<QWidget*>(widget));
}

void QLayout_Invalidate(void* ptr)
{
	static_cast<QLayout*>(ptr)->invalidate();
}

void QLayout_InvalidateDefault(void* ptr)
{
	static_cast<QLayout*>(ptr)->QLayout::invalidate();
}

char QLayout_IsEmpty(void* ptr)
{
	return static_cast<QLayout*>(ptr)->isEmpty();
}

char QLayout_IsEmptyDefault(void* ptr)
{
	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_Layout(void* ptr)
{
	return static_cast<QLayout*>(ptr)->layout();
}

void* QLayout_LayoutDefault(void* ptr)
{
	return static_cast<QLayout*>(ptr)->QLayout::layout();
}

void* QLayout_MaximumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLayout*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QLayout_MaximumSizeDefault(void* ptr)
{
	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)
{
	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)
{
	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_SetAlignment2(void* ptr, void* l, long long alignment)
{
	return static_cast<QLayout*>(ptr)->setAlignment(static_cast<QLayout*>(l), static_cast<Qt::AlignmentFlag>(alignment));
}

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));
}

void QLayout_SetContentsMargins2(void* ptr, void* margins)
{
	static_cast<QLayout*>(ptr)->setContentsMargins(*static_cast<QMargins*>(margins));
}

void QLayout_SetContentsMargins(void* ptr, int left, int top, int right, int bottom)
{
	static_cast<QLayout*>(ptr)->setContentsMargins(left, top, right, bottom);
}

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)
{
	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_TakeAt(void* ptr, int index)
{
	return static_cast<QLayout*>(ptr)->takeAt(index);
}

void QLayout_Update(void* ptr)
{
	static_cast<QLayout*>(ptr)->update();
}

void QLayout_TimerEvent(void* ptr, void* event)
{
	static_cast<QLayout*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QLayout_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QLayout*>(ptr)->QLayout::timerEvent(static_cast<QTimerEvent*>(event));
}

void QLayout_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QLayout*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QLayout_ConnectNotifyDefault(void* ptr, void* sign)
{
	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)
{
	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)
{
	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)
{
	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)
{
	return static_cast<QLayout*>(ptr)->QLayout::event(static_cast<QEvent*>(e));
}

char QLayout_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QLayout_EventFilterDefault(void* ptr, void* watched, void* event)
{
	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)
{
	return const_cast<QMetaObject*>(static_cast<QLayout*>(ptr)->QLayout::metaObject());
}

char QLayout_HasHeightForWidth(void* ptr)
{
	return static_cast<QLayout*>(ptr)->hasHeightForWidth();
}

char QLayout_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QLayout*>(ptr)->QLayout::hasHeightForWidth();
}

int QLayout_HeightForWidth(void* ptr, int w)
{
	return static_cast<QLayout*>(ptr)->heightForWidth(w);
}

int QLayout_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QLayout*>(ptr)->QLayout::heightForWidth(w);
}

int QLayout_MinimumHeightForWidth(void* ptr, int w)
{
	return static_cast<QLayout*>(ptr)->minimumHeightForWidth(w);
}

int QLayout_MinimumHeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QLayout*>(ptr)->QLayout::minimumHeightForWidth(w);
}

void* QLayout_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLayout*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}



void* QLayout_SpacerItem(void* ptr)
{
	return static_cast<QLayout*>(ptr)->spacerItem();
}

void* QLayout_SpacerItemDefault(void* ptr)
{
	return static_cast<QLayout*>(ptr)->QLayout::spacerItem();
}

void* QLayout_Widget(void* ptr)
{
	return static_cast<QLayout*>(ptr)->widget();
}

void* QLayout_WidgetDefault(void* ptr)
{
	return static_cast<QLayout*>(ptr)->QLayout::widget();
}

class MyQLayoutItem: public QLayoutItem
{
public:
	MyQLayoutItem(Qt::Alignment alignment) : QLayoutItem(alignment) {};
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayoutItem_ControlTypes(const_cast<MyQLayoutItem*>(this))); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQLayoutItem_ExpandingDirections(const_cast<MyQLayoutItem*>(this))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQLayoutItem_Geometry(const_cast<MyQLayoutItem*>(this))); };
	bool hasHeightForWidth() const { return callbackQLayoutItem_HasHeightForWidth(const_cast<MyQLayoutItem*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQLayoutItem_HeightForWidth(const_cast<MyQLayoutItem*>(this), w); };
	void invalidate() { callbackQLayoutItem_Invalidate(this); };
	bool isEmpty() const { return callbackQLayoutItem_IsEmpty(const_cast<MyQLayoutItem*>(this)) != 0; };
	QLayout * layout() { return static_cast<QLayout*>(callbackQLayoutItem_Layout(this)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQLayoutItem_MaximumSize(const_cast<MyQLayoutItem*>(this))); };
	int minimumHeightForWidth(int w) const { return callbackQLayoutItem_MinimumHeightForWidth(const_cast<MyQLayoutItem*>(this), w); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQLayoutItem_MinimumSize(const_cast<MyQLayoutItem*>(this))); };
	void setGeometry(const QRect & r) { callbackQLayoutItem_SetGeometry(this, const_cast<QRect*>(&r)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQLayoutItem_SizeHint(const_cast<MyQLayoutItem*>(this))); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayoutItem_SpacerItem(this)); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQLayoutItem_Widget(this)); };
	 ~MyQLayoutItem() { callbackQLayoutItem_DestroyQLayoutItem(this); };
};

void* QLayoutItem_NewQLayoutItem(long long alignment)
{
	return new MyQLayoutItem(static_cast<Qt::AlignmentFlag>(alignment));
}

long long QLayoutItem_Alignment(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->alignment();
}

long long QLayoutItem_ControlTypes(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->controlTypes();
}

long long QLayoutItem_ControlTypesDefault(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->QLayoutItem::controlTypes();
}

long long QLayoutItem_ExpandingDirections(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->expandingDirections();
}

void* QLayoutItem_Geometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QLayoutItem*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

char QLayoutItem_HasHeightForWidth(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->hasHeightForWidth();
}

char QLayoutItem_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->QLayoutItem::hasHeightForWidth();
}

int QLayoutItem_HeightForWidth(void* ptr, int w)
{
	return static_cast<QLayoutItem*>(ptr)->heightForWidth(w);
}

int QLayoutItem_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QLayoutItem*>(ptr)->QLayoutItem::heightForWidth(w);
}

void QLayoutItem_Invalidate(void* ptr)
{
	static_cast<QLayoutItem*>(ptr)->invalidate();
}

void QLayoutItem_InvalidateDefault(void* ptr)
{
	static_cast<QLayoutItem*>(ptr)->QLayoutItem::invalidate();
}

char QLayoutItem_IsEmpty(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->isEmpty();
}

void* QLayoutItem_Layout(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->layout();
}

void* QLayoutItem_LayoutDefault(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->QLayoutItem::layout();
}

void* QLayoutItem_MaximumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLayoutItem*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QLayoutItem_MinimumHeightForWidth(void* ptr, int w)
{
	return static_cast<QLayoutItem*>(ptr)->minimumHeightForWidth(w);
}

int QLayoutItem_MinimumHeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QLayoutItem*>(ptr)->QLayoutItem::minimumHeightForWidth(w);
}

void* QLayoutItem_MinimumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLayoutItem*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QLayoutItem_SetAlignment(void* ptr, long long alignment)
{
	static_cast<QLayoutItem*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}

void QLayoutItem_SetGeometry(void* ptr, void* r)
{
	static_cast<QLayoutItem*>(ptr)->setGeometry(*static_cast<QRect*>(r));
}

void* QLayoutItem_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLayoutItem*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QLayoutItem_SpacerItem(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->spacerItem();
}

void* QLayoutItem_SpacerItemDefault(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->QLayoutItem::spacerItem();
}

void* QLayoutItem_Widget(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->widget();
}

void* QLayoutItem_WidgetDefault(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->QLayoutItem::widget();
}

void QLayoutItem_DestroyQLayoutItem(void* ptr)
{
	static_cast<QLayoutItem*>(ptr)->~QLayoutItem();
}

void QLayoutItem_DestroyQLayoutItemDefault(void* ptr)
{

}

long long QLayoutItem_Align(void* ptr)
{
	return static_cast<QLayoutItem*>(ptr)->align;
}

void QLayoutItem_SetAlign(void* ptr, long long vqt)
{
	static_cast<QLayoutItem*>(ptr)->align = static_cast<Qt::AlignmentFlag>(vqt);
}

class MyQLineEdit: public QLineEdit
{
public:
	MyQLineEdit(QWidget *parent) : QLineEdit(parent) {};
	MyQLineEdit(const QString &contents, QWidget *parent) : QLineEdit(contents, parent) {};
	void setText(const QString & vqs) { callbackQLineEdit_SetText(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void changeEvent(QEvent * ev) { callbackQLineEdit_ChangeEvent(this, ev); };
	void clear() { callbackQLineEdit_Clear(this); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQLineEdit_ContextMenuEvent(this, event); };
	void copy() const { callbackQLineEdit_Copy(const_cast<MyQLineEdit*>(this)); };
	void Signal_CursorPositionChanged(int old, int n) { callbackQLineEdit_CursorPositionChanged(this, old, n); };
	void cut() { callbackQLineEdit_Cut(this); };
	void dragEnterEvent(QDragEnterEvent * e) { callbackQLineEdit_DragEnterEvent(this, e); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQLineEdit_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQLineEdit_DragMoveEvent(this, e); };
	void dropEvent(QDropEvent * e) { callbackQLineEdit_DropEvent(this, e); };
	void Signal_EditingFinished() { callbackQLineEdit_EditingFinished(this); };
	void focusInEvent(QFocusEvent * e) { callbackQLineEdit_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQLineEdit_FocusOutEvent(this, e); };
	void inputMethodEvent(QInputMethodEvent * e) { callbackQLineEdit_InputMethodEvent(this, e); };
	QVariant inputMethodQuery(Qt::InputMethodQuery property) const { return *static_cast<QVariant*>(callbackQLineEdit_InputMethodQuery(const_cast<MyQLineEdit*>(this), property)); };
	void keyPressEvent(QKeyEvent * event) { callbackQLineEdit_KeyPressEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQLineEdit_MinimumSizeHint(const_cast<MyQLineEdit*>(this))); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQLineEdit_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQLineEdit_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQLineEdit_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQLineEdit_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * vqp) { callbackQLineEdit_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); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQLineEdit_SizeHint(const_cast<MyQLineEdit*>(this))); };
	void Signal_TextChanged(const QString & text) { callbackQLineEdit_TextChanged(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_TextEdited(const QString & text) { callbackQLineEdit_TextEdited(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void undo() { callbackQLineEdit_Undo(this); };
	void actionEvent(QActionEvent * event) { callbackQLineEdit_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQLineEdit_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQLineEdit_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQLineEdit_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQLineEdit_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQLineEdit_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQLineEdit_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQLineEdit_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQLineEdit_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQLineEdit_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQLineEdit_ShowEvent(this, event); };
	bool close() { return callbackQLineEdit_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQLineEdit_CloseEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQLineEdit_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQLineEdit_HasHeightForWidth(const_cast<MyQLineEdit*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQLineEdit_HeightForWidth(const_cast<MyQLineEdit*>(this), w); };
	void hide() { callbackQLineEdit_Hide(this); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQLineEdit_KeyReleaseEvent(this, event); };
	void lower() { callbackQLineEdit_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQLineEdit_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQLineEdit_Raise(this); };
	void repaint() { callbackQLineEdit_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQLineEdit_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQLineEdit_SetDisabled(this, disable); };
	void setFocus() { callbackQLineEdit_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQLineEdit_SetHidden(this, hidden); };
	void show() { callbackQLineEdit_Show(this); };
	void showFullScreen() { callbackQLineEdit_ShowFullScreen(this); };
	void showMaximized() { callbackQLineEdit_ShowMaximized(this); };
	void showMinimized() { callbackQLineEdit_ShowMinimized(this); };
	void showNormal() { callbackQLineEdit_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQLineEdit_TabletEvent(this, event); };
	void update() { callbackQLineEdit_Update(this); };
	void updateMicroFocus() { callbackQLineEdit_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQLineEdit_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQLineEdit_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQLineEdit_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQLineEdit_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQLineEdit_CustomEvent(this, event); };
	void deleteLater() { callbackQLineEdit_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQLineEdit_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQLineEdit_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLineEdit_MetaObject(const_cast<MyQLineEdit*>(this))); };
};

long long QLineEdit_Alignment(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->alignment();
}

long long QLineEdit_CursorMoveStyle(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->cursorMoveStyle();
}

int QLineEdit_CursorPosition(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->cursorPosition();
}

char* QLineEdit_DisplayText(void* ptr)
{
	return const_cast<char*>(static_cast<QLineEdit*>(ptr)->displayText().toUtf8().prepend("WHITESPACE").constData()+10);
}

char QLineEdit_DragEnabled(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->dragEnabled();
}

long long QLineEdit_EchoMode(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->echoMode();
}

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();
}

char* QLineEdit_InputMask(void* ptr)
{
	return const_cast<char*>(static_cast<QLineEdit*>(ptr)->inputMask().toUtf8().prepend("WHITESPACE").constData()+10);
}

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();
}

char* QLineEdit_PlaceholderText(void* ptr)
{
	return const_cast<char*>(static_cast<QLineEdit*>(ptr)->placeholderText().toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QLineEdit_SelectedText(void* ptr)
{
	return const_cast<char*>(static_cast<QLineEdit*>(ptr)->selectedText().toUtf8().prepend("WHITESPACE").constData()+10);
}

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_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 vec)
{
	static_cast<QLineEdit*>(ptr)->setEchoMode(static_cast<QLineEdit::EchoMode>(vec));
}

void QLineEdit_SetFrame(void* ptr, char vbo)
{
	static_cast<QLineEdit*>(ptr)->setFrame(vbo != 0);
}

void QLineEdit_SetInputMask(void* ptr, char* inputMask)
{
	static_cast<QLineEdit*>(ptr)->setInputMask(QString(inputMask));
}

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, char* vqs)
{
	static_cast<QLineEdit*>(ptr)->setPlaceholderText(QString(vqs));
}

void QLineEdit_SetReadOnly(void* ptr, char vbo)
{
	static_cast<QLineEdit*>(ptr)->setReadOnly(vbo != 0);
}

void QLineEdit_SetText(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setText", Q_ARG(QString, QString(vqs)));
}

char* QLineEdit_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QLineEdit*>(ptr)->text().toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QLineEdit_NewQLineEdit(void* parent)
{
	return new MyQLineEdit(static_cast<QWidget*>(parent));
}

void* QLineEdit_NewQLineEdit2(char* contents, void* parent)
{
	return new MyQLineEdit(QString(contents), static_cast<QWidget*>(parent));
}

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));
}

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_Backspace(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->backspace();
}

void QLineEdit_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QLineEdit*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QLineEdit_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::changeEvent(static_cast<QEvent*>(ev));
}

void QLineEdit_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "clear");
}

void* QLineEdit_Completer(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->completer();
}

void QLineEdit_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QLineEdit_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QLineEdit_Copy(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "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);
}

int QLineEdit_CursorPositionAt(void* ptr, void* pos)
{
	return static_cast<QLineEdit*>(ptr)->cursorPositionAt(*static_cast<QPoint*>(pos));
}

void QLineEdit_ConnectCursorPositionChanged(void* ptr)
{
	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));
}

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 old, int n)
{
	static_cast<QLineEdit*>(ptr)->cursorPositionChanged(old, n);
}

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_Del(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->del();
}

void QLineEdit_Deselect(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->deselect();
}

void QLineEdit_DragEnterEvent(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(e));
}

void QLineEdit_DragEnterEventDefault(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(e));
}

void QLineEdit_DragLeaveEvent(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QLineEdit_DragLeaveEventDefault(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QLineEdit_DragMoveEvent(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

void QLineEdit_DragMoveEventDefault(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

void QLineEdit_DropEvent(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->dropEvent(static_cast<QDropEvent*>(e));
}

void QLineEdit_DropEventDefault(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::dropEvent(static_cast<QDropEvent*>(e));
}

void QLineEdit_ConnectEditingFinished(void* ptr)
{
	QObject::connect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)()>(&QLineEdit::editingFinished), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)()>(&MyQLineEdit::Signal_EditingFinished));
}

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);
}

char QLineEdit_Event(void* ptr, void* e)
{
	return static_cast<QLineEdit*>(ptr)->event(static_cast<QEvent*>(e));
}

void QLineEdit_FocusInEvent(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(e));
}

void QLineEdit_FocusInEventDefault(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::focusInEvent(static_cast<QFocusEvent*>(e));
}

void QLineEdit_FocusOutEvent(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QLineEdit_FocusOutEventDefault(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QLineEdit_GetTextMargins(void* ptr, int left, int top, int right, int bottom)
{
	static_cast<QLineEdit*>(ptr)->getTextMargins(&left, &top, &right, &bottom);
}

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));
}

void QLineEdit_InputMethodEvent(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(e));
}

void QLineEdit_InputMethodEventDefault(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(e));
}

void* QLineEdit_InputMethodQuery(void* ptr, long long property)
{
	return new QVariant(static_cast<QLineEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(property)));
}

void* QLineEdit_InputMethodQueryDefault(void* ptr, long long property)
{
	return new QVariant(static_cast<QLineEdit*>(ptr)->QLineEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(property)));
}

void QLineEdit_Insert(void* ptr, char* newText)
{
	static_cast<QLineEdit*>(ptr)->insert(QString(newText));
}

void QLineEdit_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QLineEdit_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void* QLineEdit_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLineEdit*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QLineEdit_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLineEdit*>(ptr)->QLineEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QLineEdit_MouseDoubleClickEvent(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QLineEdit_MouseDoubleClickEventDefault(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QLineEdit_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QLineEdit_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QLineEdit_MousePressEvent(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QLineEdit_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QLineEdit_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QLineEdit_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QLineEdit_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QLineEdit*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QLineEdit_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QLineEdit_Paste(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "paste");
}

void QLineEdit_Redo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "redo");
}

void QLineEdit_ConnectReturnPressed(void* ptr)
{
	QObject::connect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)()>(&QLineEdit::returnPressed), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)()>(&MyQLineEdit::Signal_ReturnPressed));
}

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_ConnectSelectionChanged(void* ptr)
{
	QObject::connect(static_cast<QLineEdit*>(ptr), static_cast<void (QLineEdit::*)()>(&QLineEdit::selectionChanged), static_cast<MyQLineEdit*>(ptr), static_cast<void (MyQLineEdit::*)()>(&MyQLineEdit::Signal_SelectionChanged));
}

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_SelectionStart(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->selectionStart();
}

void QLineEdit_SetCompleter(void* ptr, void* c)
{
	static_cast<QLineEdit*>(ptr)->setCompleter(static_cast<QCompleter*>(c));
}

void QLineEdit_SetSelection(void* ptr, int start, int length)
{
	static_cast<QLineEdit*>(ptr)->setSelection(start, length);
}

void QLineEdit_SetTextMargins2(void* ptr, void* margins)
{
	static_cast<QLineEdit*>(ptr)->setTextMargins(*static_cast<QMargins*>(margins));
}

void QLineEdit_SetTextMargins(void* ptr, int left, int top, int right, int bottom)
{
	static_cast<QLineEdit*>(ptr)->setTextMargins(left, top, right, bottom);
}

void QLineEdit_SetValidator(void* ptr, void* v)
{
	static_cast<QLineEdit*>(ptr)->setValidator(static_cast<QValidator*>(v));
}

void* QLineEdit_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLineEdit*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QLineEdit_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QLineEdit*>(ptr)->QLineEdit::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QLineEdit_ConnectTextChanged(void* ptr)
{
	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));
}

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, char* text)
{
	static_cast<QLineEdit*>(ptr)->textChanged(QString(text));
}

void QLineEdit_ConnectTextEdited(void* ptr)
{
	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));
}

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, char* text)
{
	static_cast<QLineEdit*>(ptr)->textEdited(QString(text));
}

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_Validator(void* ptr)
{
	return const_cast<QValidator*>(static_cast<QLineEdit*>(ptr)->validator());
}

void QLineEdit_DestroyQLineEdit(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->~QLineEdit();
}

void QLineEdit_ActionEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QLineEdit_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::actionEvent(static_cast<QActionEvent*>(event));
}

void QLineEdit_EnterEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QLineEdit_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::enterEvent(static_cast<QEvent*>(event));
}

void QLineEdit_HideEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QLineEdit_HideEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::hideEvent(static_cast<QHideEvent*>(event));
}

void QLineEdit_LeaveEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QLineEdit_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::leaveEvent(static_cast<QEvent*>(event));
}

void QLineEdit_MoveEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QLineEdit_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::moveEvent(static_cast<QMoveEvent*>(event));
}

void QLineEdit_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QLineEdit_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::setEnabled(vbo != 0);
}

void QLineEdit_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QLineEdit_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::setStyleSheet(QString(styleSheet));
}

void QLineEdit_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QLineEdit_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::setVisible(visible != 0);
}

void QLineEdit_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QLineEdit_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::setWindowModified(vbo != 0);
}

void QLineEdit_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QLineEdit_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::setWindowTitle(QString(vqs));
}

void QLineEdit_ShowEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QLineEdit_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::showEvent(static_cast<QShowEvent*>(event));
}

char QLineEdit_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QLineEdit_CloseDefault(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->QLineEdit::close();
}

void QLineEdit_CloseEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QLineEdit_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::closeEvent(static_cast<QCloseEvent*>(event));
}

char QLineEdit_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QLineEdit*>(ptr)->focusNextPrevChild(next != 0);
}

char QLineEdit_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QLineEdit*>(ptr)->QLineEdit::focusNextPrevChild(next != 0);
}

char QLineEdit_HasHeightForWidth(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->hasHeightForWidth();
}

char QLineEdit_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QLineEdit*>(ptr)->QLineEdit::hasHeightForWidth();
}

int QLineEdit_HeightForWidth(void* ptr, int w)
{
	return static_cast<QLineEdit*>(ptr)->heightForWidth(w);
}

int QLineEdit_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QLineEdit*>(ptr)->QLineEdit::heightForWidth(w);
}

void QLineEdit_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "hide");
}

void QLineEdit_HideDefault(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::hide();
}

void QLineEdit_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QLineEdit_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QLineEdit_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "lower");
}

void QLineEdit_LowerDefault(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::lower();
}

char QLineEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QLineEdit*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QLineEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QLineEdit*>(ptr)->QLineEdit::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QLineEdit_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "raise");
}

void QLineEdit_RaiseDefault(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::raise();
}

void QLineEdit_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "repaint");
}

void QLineEdit_RepaintDefault(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::repaint();
}

void QLineEdit_ResizeEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QLineEdit_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QLineEdit_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QLineEdit_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::setDisabled(disable != 0);
}

void QLineEdit_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setFocus");
}

void QLineEdit_SetFocus2Default(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::setFocus();
}

void QLineEdit_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QLineEdit_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::setHidden(hidden != 0);
}

void QLineEdit_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "show");
}

void QLineEdit_ShowDefault(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::show();
}

void QLineEdit_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "showFullScreen");
}

void QLineEdit_ShowFullScreenDefault(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::showFullScreen();
}

void QLineEdit_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "showMaximized");
}

void QLineEdit_ShowMaximizedDefault(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::showMaximized();
}

void QLineEdit_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "showMinimized");
}

void QLineEdit_ShowMinimizedDefault(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::showMinimized();
}

void QLineEdit_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "showNormal");
}

void QLineEdit_ShowNormalDefault(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::showNormal();
}

void QLineEdit_TabletEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QLineEdit_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QLineEdit_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "update");
}

void QLineEdit_UpdateDefault(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::update();
}

void QLineEdit_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "updateMicroFocus");
}

void QLineEdit_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::updateMicroFocus();
}

void QLineEdit_WheelEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QLineEdit_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QLineEdit_TimerEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QLineEdit_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::timerEvent(static_cast<QTimerEvent*>(event));
}

void QLineEdit_ChildEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QLineEdit_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::childEvent(static_cast<QChildEvent*>(event));
}

void QLineEdit_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QLineEdit*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QLineEdit_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QLineEdit_CustomEvent(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QLineEdit_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::customEvent(static_cast<QEvent*>(event));
}

void QLineEdit_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "deleteLater");
}

void QLineEdit_DeleteLaterDefault(void* ptr)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::deleteLater();
}

void QLineEdit_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QLineEdit*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QLineEdit_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QLineEdit*>(ptr)->QLineEdit::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QLineEdit_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QLineEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QLineEdit_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QLineEdit*>(ptr)->QLineEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QLineEdit_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QLineEdit*>(ptr)->metaObject());
}

void* QLineEdit_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QLineEdit*>(ptr)->QLineEdit::metaObject());
}

class MyQListView: public QListView
{
public:
	MyQListView(QWidget *parent) : QListView(parent) {};
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQListView_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQListView_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQListView_DragMoveEvent(this, e); };
	void dropEvent(QDropEvent * e) { callbackQListView_DropEvent(this, e); };
	int horizontalOffset() const { return callbackQListView_HorizontalOffset(const_cast<MyQListView*>(this)); };
	QModelIndex indexAt(const QPoint & p) const { return *static_cast<QModelIndex*>(callbackQListView_IndexAt(const_cast<MyQListView*>(this), const_cast<QPoint*>(&p))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQListView_IsIndexHidden(const_cast<MyQListView*>(this), const_cast<QModelIndex*>(&index)) != 0; };
	void mouseMoveEvent(QMouseEvent * e) { callbackQListView_MouseMoveEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQListView_MouseReleaseEvent(this, e); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQListView_MoveCursor(this, cursorAction, modifiers)); };
	void paintEvent(QPaintEvent * e) { callbackQListView_PaintEvent(this, e); };
	void resizeEvent(QResizeEvent * e) { callbackQListView_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); };
	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) { callbackQListView_StartDrag(this, supportedActions); };
	void updateGeometries() { callbackQListView_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQListView_VerticalOffset(const_cast<MyQListView*>(this)); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQListView_ViewOptions(const_cast<MyQListView*>(this))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQListView_ViewportSizeHint(const_cast<MyQListView*>(this))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQListView_VisualRect(const_cast<MyQListView*>(this), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQListView_VisualRegionForSelection(const_cast<MyQListView*>(this), const_cast<QItemSelection*>(&selection))); };
	void wheelEvent(QWheelEvent * e) { callbackQListView_WheelEvent(this, e); };
	bool viewportEvent(QEvent * event) { return callbackQListView_ViewportEvent(this, event) != 0; };
	void clearSelection() { callbackQListView_ClearSelection(this); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQListView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQListView_CommitData(this, editor); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQListView_DragEnterEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQListView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQListView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQListView_EditorDestroyed(this, editor); };
	void focusInEvent(QFocusEvent * event) { callbackQListView_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQListView_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQListView_FocusOutEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQListView_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQListView_InputMethodQuery(const_cast<MyQListView*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQListView_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { callbackQListView_KeyboardSearch(this, const_cast<char*>(search.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQListView_MouseDoubleClickEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQListView_MousePressEvent(this, event); };
	void reset() { callbackQListView_Reset(this); };
	void scrollToBottom() { callbackQListView_ScrollToBottom(this); };
	void scrollToTop() { callbackQListView_ScrollToTop(this); };
	void selectAll() { callbackQListView_SelectAll(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQListView_SelectionCommand(const_cast<MyQListView*>(this), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQListView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	void setModel(QAbstractItemModel * model) { callbackQListView_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQListView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQListView_SetSelectionModel(this, selectionModel); };
	int sizeHintForColumn(int column) const { return callbackQListView_SizeHintForColumn(const_cast<MyQListView*>(this), column); };
	int sizeHintForRow(int row) const { return callbackQListView_SizeHintForRow(const_cast<MyQListView*>(this), row); };
	void update(const QModelIndex & index) { callbackQListView_Update(this, const_cast<QModelIndex*>(&index)); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQListView_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQListView_MinimumSizeHint(const_cast<MyQListView*>(this))); };
	void scrollContentsBy(int dx, int dy) { callbackQListView_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQListView_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQListView_SizeHint(const_cast<MyQListView*>(this))); };
	void changeEvent(QEvent * ev) { callbackQListView_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQListView_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQListView_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQListView_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQListView_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQListView_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQListView_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQListView_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQListView_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQListView_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQListView_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQListView_ShowEvent(this, event); };
	bool close() { return callbackQListView_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQListView_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQListView_HasHeightForWidth(const_cast<MyQListView*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQListView_HeightForWidth(const_cast<MyQListView*>(this), w); };
	void hide() { callbackQListView_Hide(this); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQListView_KeyReleaseEvent(this, event); };
	void lower() { callbackQListView_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQListView_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQListView_Raise(this); };
	void repaint() { callbackQListView_Repaint(this); };
	void setDisabled(bool disable) { callbackQListView_SetDisabled(this, disable); };
	void setFocus() { callbackQListView_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQListView_SetHidden(this, hidden); };
	void show() { callbackQListView_Show(this); };
	void showFullScreen() { callbackQListView_ShowFullScreen(this); };
	void showMaximized() { callbackQListView_ShowMaximized(this); };
	void showMinimized() { callbackQListView_ShowMinimized(this); };
	void showNormal() { callbackQListView_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQListView_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQListView_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQListView_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQListView_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQListView_CustomEvent(this, event); };
	void deleteLater() { callbackQListView_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQListView_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQListView_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQListView_MetaObject(const_cast<MyQListView*>(this))); };
};

int QListView_BatchSize(void* ptr)
{
	return static_cast<QListView*>(ptr)->batchSize();
}

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()); });
}

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_LayoutMode(void* ptr)
{
	return static_cast<QListView*>(ptr)->layoutMode();
}

int QListView_ModelColumn(void* ptr)
{
	return static_cast<QListView*>(ptr)->modelColumn();
}

long long QListView_Movement(void* ptr)
{
	return static_cast<QListView*>(ptr)->movement();
}

long long QListView_ResizeMode(void* ptr)
{
	return static_cast<QListView*>(ptr)->resizeMode();
}

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_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_SetResizeMode(void* ptr, long long mode)
{
	static_cast<QListView*>(ptr)->setResizeMode(static_cast<QListView::ResizeMode>(mode));
}

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();
}

long long QListView_ViewMode(void* ptr)
{
	return static_cast<QListView*>(ptr)->viewMode();
}

char QListView_WordWrap(void* ptr)
{
	return static_cast<QListView*>(ptr)->wordWrap();
}

void* QListView_NewQListView(void* parent)
{
	return new MyQListView(static_cast<QWidget*>(parent));
}

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)
{
	static_cast<QListView*>(ptr)->QListView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QListView_DragLeaveEvent(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QListView_DragLeaveEventDefault(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->QListView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QListView_DragMoveEvent(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

void QListView_DragMoveEventDefault(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->QListView::dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

void QListView_DropEvent(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->dropEvent(static_cast<QDropEvent*>(e));
}

void QListView_DropEventDefault(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->QListView::dropEvent(static_cast<QDropEvent*>(e));
}

char QListView_Event(void* ptr, void* e)
{
	return static_cast<QListView*>(ptr)->event(static_cast<QEvent*>(e));
}

int QListView_HorizontalOffset(void* ptr)
{
	return static_cast<QListView*>(ptr)->horizontalOffset();
}

int QListView_HorizontalOffsetDefault(void* ptr)
{
	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)
{
	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)
{
	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);
}

void QListView_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QListView_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->QListView::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QListView_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QListView_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->QListView::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

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)
{
	return new QModelIndex(static_cast<QListView*>(ptr)->QListView::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void QListView_PaintEvent(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->paintEvent(static_cast<QPaintEvent*>(e));
}

void QListView_PaintEventDefault(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->QListView::paintEvent(static_cast<QPaintEvent*>(e));
}

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()); });
}

void QListView_ResizeEvent(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(e));
}

void QListView_ResizeEventDefault(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->QListView::resizeEvent(static_cast<QResizeEvent*>(e));
}

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)
{
	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)
{
	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)
{
	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)
{
	static_cast<QListView*>(ptr)->QListView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

void QListView_SetPositionForIndex(void* ptr, void* position, void* index)
{
	static_cast<QListView*>(ptr)->setPositionForIndex(*static_cast<QPoint*>(position), *static_cast<QModelIndex*>(index));
}

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)
{
	static_cast<QListView*>(ptr)->QListView::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QListView_StartDrag(void* ptr, long long supportedActions)
{
	static_cast<QListView*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QListView_StartDragDefault(void* ptr, long long supportedActions)
{
	static_cast<QListView*>(ptr)->QListView::startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QListView_TimerEvent(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->timerEvent(static_cast<QTimerEvent*>(e));
}

void QListView_UpdateGeometries(void* ptr)
{
	static_cast<QListView*>(ptr)->updateGeometries();
}

void QListView_UpdateGeometriesDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::updateGeometries();
}

int QListView_VerticalOffset(void* ptr)
{
	return static_cast<QListView*>(ptr)->verticalOffset();
}

int QListView_VerticalOffsetDefault(void* ptr)
{
	return static_cast<QListView*>(ptr)->QListView::verticalOffset();
}

void* QListView_ViewOptions(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QListView*>(ptr)->viewOptions());
}

void* QListView_ViewOptionsDefault(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QListView*>(ptr)->QListView::viewOptions());
}

void* QListView_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListView*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QListView_ViewportSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListView*>(ptr)->QListView::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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)
{
	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)
{
	return new QRegion(static_cast<QListView*>(ptr)->QListView::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void QListView_WheelEvent(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QListView_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->QListView::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QListView_DestroyQListView(void* ptr)
{
	static_cast<QListView*>(ptr)->~QListView();
}

char QListView_ViewportEvent(void* ptr, void* event)
{
	return static_cast<QListView*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}

char QListView_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QListView*>(ptr)->QListView::viewportEvent(static_cast<QEvent*>(event));
}

void QListView_ClearSelection(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "clearSelection");
}

void QListView_ClearSelectionDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::clearSelection();
}

void QListView_CloseEditor(void* ptr, void* editor, long long hint)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "closeEditor", Q_ARG(QWidget*, static_cast<QWidget*>(editor)), Q_ARG(QAbstractItemDelegate::EndEditHint, static_cast<QAbstractItemDelegate::EndEditHint>(hint)));
}

void QListView_CloseEditorDefault(void* ptr, void* editor, long long hint)
{
	static_cast<QListView*>(ptr)->QListView::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
}

void QListView_CommitData(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "commitData", Q_ARG(QWidget*, static_cast<QWidget*>(editor)));
}

void QListView_CommitDataDefault(void* ptr, void* editor)
{
	static_cast<QListView*>(ptr)->QListView::commitData(static_cast<QWidget*>(editor));
}

void QListView_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QListView_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QListView_Edit(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "edit", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QListView_EditDefault(void* ptr, void* index)
{
	static_cast<QListView*>(ptr)->QListView::edit(*static_cast<QModelIndex*>(index));
}

char QListView_Edit2(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QListView*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

char QListView_Edit2Default(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QListView*>(ptr)->QListView::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

void QListView_EditorDestroyed(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "editorDestroyed", Q_ARG(QObject*, static_cast<QObject*>(editor)));
}

void QListView_EditorDestroyedDefault(void* ptr, void* editor)
{
	static_cast<QListView*>(ptr)->QListView::editorDestroyed(static_cast<QObject*>(editor));
}

void QListView_FocusInEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QListView_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QListView_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QListView*>(ptr)->focusNextPrevChild(next != 0);
}

char QListView_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QListView*>(ptr)->QListView::focusNextPrevChild(next != 0);
}

void QListView_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QListView_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QListView_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QListView_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QListView_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QListView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QListView_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QListView*>(ptr)->QListView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QListView_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QListView_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QListView_KeyboardSearch(void* ptr, char* search)
{
	static_cast<QListView*>(ptr)->keyboardSearch(QString(search));
}

void QListView_KeyboardSearchDefault(void* ptr, char* search)
{
	static_cast<QListView*>(ptr)->QListView::keyboardSearch(QString(search));
}

void QListView_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QListView_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QListView_MousePressEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QListView_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QListView_Reset(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "reset");
}

void QListView_ResetDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::reset();
}

void QListView_ScrollToBottom(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "scrollToBottom");
}

void QListView_ScrollToBottomDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::scrollToBottom();
}

void QListView_ScrollToTop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "scrollToTop");
}

void QListView_ScrollToTopDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::scrollToTop();
}

void QListView_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "selectAll");
}

void QListView_SelectAllDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::selectAll();
}

long long QListView_SelectionCommand(void* ptr, void* index, void* event)
{
	return static_cast<QListView*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

long long QListView_SelectionCommandDefault(void* ptr, void* index, void* event)
{
	return static_cast<QListView*>(ptr)->QListView::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

void QListView_SetCurrentIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setCurrentIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QListView_SetCurrentIndexDefault(void* ptr, void* index)
{
	static_cast<QListView*>(ptr)->QListView::setCurrentIndex(*static_cast<QModelIndex*>(index));
}

void QListView_SetModel(void* ptr, void* model)
{
	static_cast<QListView*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}

void QListView_SetModelDefault(void* ptr, void* model)
{
	static_cast<QListView*>(ptr)->QListView::setModel(static_cast<QAbstractItemModel*>(model));
}

void QListView_SetRootIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setRootIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QListView_SetRootIndexDefault(void* ptr, void* index)
{
	static_cast<QListView*>(ptr)->QListView::setRootIndex(*static_cast<QModelIndex*>(index));
}

void QListView_SetSelectionModel(void* ptr, void* selectionModel)
{
	static_cast<QListView*>(ptr)->setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

void QListView_SetSelectionModelDefault(void* ptr, void* selectionModel)
{
	static_cast<QListView*>(ptr)->QListView::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

int QListView_SizeHintForColumn(void* ptr, int column)
{
	return static_cast<QListView*>(ptr)->sizeHintForColumn(column);
}

int QListView_SizeHintForColumnDefault(void* ptr, int column)
{
	return static_cast<QListView*>(ptr)->QListView::sizeHintForColumn(column);
}

int QListView_SizeHintForRow(void* ptr, int row)
{
	return static_cast<QListView*>(ptr)->sizeHintForRow(row);
}

int QListView_SizeHintForRowDefault(void* ptr, int row)
{
	return static_cast<QListView*>(ptr)->QListView::sizeHintForRow(row);
}

void QListView_Update(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "update", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QListView_UpdateDefault(void* ptr, void* index)
{
	static_cast<QListView*>(ptr)->QListView::update(*static_cast<QModelIndex*>(index));
}

void QListView_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QListView_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QListView*>(ptr)->QListView::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void* QListView_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListView*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QListView_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListView*>(ptr)->QListView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QListView_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QListView*>(ptr)->scrollContentsBy(dx, dy);
}

void QListView_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QListView*>(ptr)->QListView::scrollContentsBy(dx, dy);
}

void QListView_SetupViewport(void* ptr, void* viewport)
{
	static_cast<QListView*>(ptr)->setupViewport(static_cast<QWidget*>(viewport));
}

void QListView_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QListView*>(ptr)->QListView::setupViewport(static_cast<QWidget*>(viewport));
}

void* QListView_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListView*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QListView_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListView*>(ptr)->QListView::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QListView_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QListView*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QListView_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QListView*>(ptr)->QListView::changeEvent(static_cast<QEvent*>(ev));
}

void QListView_ActionEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QListView_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::actionEvent(static_cast<QActionEvent*>(event));
}

void QListView_EnterEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QListView_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::enterEvent(static_cast<QEvent*>(event));
}

void QListView_HideEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QListView_HideEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::hideEvent(static_cast<QHideEvent*>(event));
}

void QListView_LeaveEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QListView_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::leaveEvent(static_cast<QEvent*>(event));
}

void QListView_MoveEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QListView_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::moveEvent(static_cast<QMoveEvent*>(event));
}

void QListView_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QListView_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QListView*>(ptr)->QListView::setEnabled(vbo != 0);
}

void QListView_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QListView_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QListView*>(ptr)->QListView::setStyleSheet(QString(styleSheet));
}

void QListView_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QListView_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QListView*>(ptr)->QListView::setVisible(visible != 0);
}

void QListView_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QListView_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QListView*>(ptr)->QListView::setWindowModified(vbo != 0);
}

void QListView_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QListView_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QListView*>(ptr)->QListView::setWindowTitle(QString(vqs));
}

void QListView_ShowEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QListView_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::showEvent(static_cast<QShowEvent*>(event));
}

char QListView_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QListView_CloseDefault(void* ptr)
{
	return static_cast<QListView*>(ptr)->QListView::close();
}

void QListView_CloseEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QListView_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::closeEvent(static_cast<QCloseEvent*>(event));
}

char QListView_HasHeightForWidth(void* ptr)
{
	return static_cast<QListView*>(ptr)->hasHeightForWidth();
}

char QListView_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QListView*>(ptr)->QListView::hasHeightForWidth();
}

int QListView_HeightForWidth(void* ptr, int w)
{
	return static_cast<QListView*>(ptr)->heightForWidth(w);
}

int QListView_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QListView*>(ptr)->QListView::heightForWidth(w);
}

void QListView_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "hide");
}

void QListView_HideDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::hide();
}

void QListView_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QListView_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QListView_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "lower");
}

void QListView_LowerDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::lower();
}

char QListView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QListView*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QListView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QListView*>(ptr)->QListView::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QListView_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "raise");
}

void QListView_RaiseDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::raise();
}

void QListView_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "repaint");
}

void QListView_RepaintDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::repaint();
}

void QListView_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QListView_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QListView*>(ptr)->QListView::setDisabled(disable != 0);
}

void QListView_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setFocus");
}

void QListView_SetFocus2Default(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::setFocus();
}

void QListView_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QListView_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QListView*>(ptr)->QListView::setHidden(hidden != 0);
}

void QListView_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "show");
}

void QListView_ShowDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::show();
}

void QListView_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "showFullScreen");
}

void QListView_ShowFullScreenDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::showFullScreen();
}

void QListView_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "showMaximized");
}

void QListView_ShowMaximizedDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::showMaximized();
}

void QListView_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "showMinimized");
}

void QListView_ShowMinimizedDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::showMinimized();
}

void QListView_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "showNormal");
}

void QListView_ShowNormalDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::showNormal();
}

void QListView_TabletEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QListView_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QListView_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "updateMicroFocus");
}

void QListView_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::updateMicroFocus();
}

void QListView_ChildEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QListView_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::childEvent(static_cast<QChildEvent*>(event));
}

void QListView_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QListView*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QListView_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QListView*>(ptr)->QListView::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QListView_CustomEvent(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QListView_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QListView*>(ptr)->QListView::customEvent(static_cast<QEvent*>(event));
}

void QListView_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "deleteLater");
}

void QListView_DeleteLaterDefault(void* ptr)
{
	static_cast<QListView*>(ptr)->QListView::deleteLater();
}

void QListView_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QListView*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QListView_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QListView*>(ptr)->QListView::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QListView_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QListView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QListView_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QListView*>(ptr)->QListView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QListView_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QListView*>(ptr)->metaObject());
}

void* QListView_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QListView*>(ptr)->QListView::metaObject());
}

class MyQListWidget: public QListWidget
{
public:
	MyQListWidget(QWidget *parent) : QListWidget(parent) {};
	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) { callbackQListWidget_CurrentTextChanged(this, const_cast<char*>(currentText.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void dropEvent(QDropEvent * event) { callbackQListWidget_DropEvent(this, event); };
	bool dropMimeData(int index, const QMimeData * data, Qt::DropAction action) { return callbackQListWidget_DropMimeData(this, index, const_cast<QMimeData*>(data), action) != 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); };
	QStringList mimeTypes() const { return QString(callbackQListWidget_MimeTypes(const_cast<MyQListWidget*>(this))).split("|", QString::SkipEmptyParts); };
	void scrollToItem(const QListWidgetItem * item, QAbstractItemView::ScrollHint hint) { callbackQListWidget_ScrollToItem(this, const_cast<QListWidgetItem*>(item), hint); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQListWidget_SetSelectionModel(this, selectionModel); };
	Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQListWidget_SupportedDropActions(const_cast<MyQListWidget*>(this))); };
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQListWidget_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQListWidget_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQListWidget_DragMoveEvent(this, e); };
	int horizontalOffset() const { return callbackQListWidget_HorizontalOffset(const_cast<MyQListWidget*>(this)); };
	QModelIndex indexAt(const QPoint & p) const { return *static_cast<QModelIndex*>(callbackQListWidget_IndexAt(const_cast<MyQListWidget*>(this), const_cast<QPoint*>(&p))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQListWidget_IsIndexHidden(const_cast<MyQListWidget*>(this), const_cast<QModelIndex*>(&index)) != 0; };
	void mouseMoveEvent(QMouseEvent * e) { callbackQListWidget_MouseMoveEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQListWidget_MouseReleaseEvent(this, e); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQListWidget_MoveCursor(this, cursorAction, modifiers)); };
	void paintEvent(QPaintEvent * e) { callbackQListWidget_PaintEvent(this, e); };
	void resizeEvent(QResizeEvent * e) { callbackQListWidget_ResizeEvent(this, e); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQListWidget_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQListWidget_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQListWidget_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQListWidget_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQListWidget_SetSelection(this, const_cast<QRect*>(&rect), command); };
	void startDrag(Qt::DropActions supportedActions) { callbackQListWidget_StartDrag(this, supportedActions); };
	void updateGeometries() { callbackQListWidget_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQListWidget_VerticalOffset(const_cast<MyQListWidget*>(this)); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQListWidget_ViewOptions(const_cast<MyQListWidget*>(this))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQListWidget_ViewportSizeHint(const_cast<MyQListWidget*>(this))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQListWidget_VisualRect(const_cast<MyQListWidget*>(this), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQListWidget_VisualRegionForSelection(const_cast<MyQListWidget*>(this), const_cast<QItemSelection*>(&selection))); };
	void wheelEvent(QWheelEvent * e) { callbackQListWidget_WheelEvent(this, e); };
	bool viewportEvent(QEvent * event) { return callbackQListWidget_ViewportEvent(this, event) != 0; };
	void clearSelection() { callbackQListWidget_ClearSelection(this); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQListWidget_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQListWidget_CommitData(this, editor); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQListWidget_DragEnterEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQListWidget_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQListWidget_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQListWidget_EditorDestroyed(this, editor); };
	void focusInEvent(QFocusEvent * event) { callbackQListWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQListWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQListWidget_FocusOutEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQListWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQListWidget_InputMethodQuery(const_cast<MyQListWidget*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQListWidget_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { callbackQListWidget_KeyboardSearch(this, const_cast<char*>(search.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQListWidget_MouseDoubleClickEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQListWidget_MousePressEvent(this, event); };
	void reset() { callbackQListWidget_Reset(this); };
	void scrollToBottom() { callbackQListWidget_ScrollToBottom(this); };
	void scrollToTop() { callbackQListWidget_ScrollToTop(this); };
	void selectAll() { callbackQListWidget_SelectAll(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQListWidget_SelectionCommand(const_cast<MyQListWidget*>(this), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQListWidget_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	void setModel(QAbstractItemModel * model) { callbackQListWidget_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQListWidget_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	int sizeHintForColumn(int column) const { return callbackQListWidget_SizeHintForColumn(const_cast<MyQListWidget*>(this), column); };
	int sizeHintForRow(int row) const { return callbackQListWidget_SizeHintForRow(const_cast<MyQListWidget*>(this), row); };
	void update(const QModelIndex & index) { callbackQListWidget_Update(this, const_cast<QModelIndex*>(&index)); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQListWidget_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQListWidget_MinimumSizeHint(const_cast<MyQListWidget*>(this))); };
	void scrollContentsBy(int dx, int dy) { callbackQListWidget_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQListWidget_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQListWidget_SizeHint(const_cast<MyQListWidget*>(this))); };
	void changeEvent(QEvent * ev) { callbackQListWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQListWidget_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQListWidget_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQListWidget_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQListWidget_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQListWidget_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQListWidget_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQListWidget_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQListWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQListWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQListWidget_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQListWidget_ShowEvent(this, event); };
	bool close() { return callbackQListWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQListWidget_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQListWidget_HasHeightForWidth(const_cast<MyQListWidget*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQListWidget_HeightForWidth(const_cast<MyQListWidget*>(this), w); };
	void hide() { callbackQListWidget_Hide(this); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQListWidget_KeyReleaseEvent(this, event); };
	void lower() { callbackQListWidget_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQListWidget_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQListWidget_Raise(this); };
	void repaint() { callbackQListWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQListWidget_SetDisabled(this, disable); };
	void setFocus() { callbackQListWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQListWidget_SetHidden(this, hidden); };
	void show() { callbackQListWidget_Show(this); };
	void showFullScreen() { callbackQListWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQListWidget_ShowMaximized(this); };
	void showMinimized() { callbackQListWidget_ShowMinimized(this); };
	void showNormal() { callbackQListWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQListWidget_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQListWidget_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQListWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQListWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQListWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQListWidget_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQListWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQListWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQListWidget_MetaObject(const_cast<MyQListWidget*>(this))); };
};

int QListWidget_Count(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->count();
}

int QListWidget_CurrentRow(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->currentRow();
}

char QListWidget_IsSortingEnabled(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->isSortingEnabled();
}

void QListWidget_SetCurrentRow(void* ptr, int row)
{
	static_cast<QListWidget*>(ptr)->setCurrentRow(row);
}

void QListWidget_SetSortingEnabled(void* ptr, char enable)
{
	static_cast<QListWidget*>(ptr)->setSortingEnabled(enable != 0);
}

void* QListWidget_NewQListWidget(void* parent)
{
	return new MyQListWidget(static_cast<QWidget*>(parent));
}

void QListWidget_AddItem2(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->addItem(static_cast<QListWidgetItem*>(item));
}

void QListWidget_AddItem(void* ptr, char* label)
{
	static_cast<QListWidget*>(ptr)->addItem(QString(label));
}

void QListWidget_AddItems(void* ptr, char* labels)
{
	static_cast<QListWidget*>(ptr)->addItems(QString(labels).split("|", QString::SkipEmptyParts));
}

void QListWidget_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "clear");
}

void QListWidget_ClosePersistentEditor(void* ptr, void* item)
{
	static_cast<QListWidget*>(ptr)->closePersistentEditor(static_cast<QListWidgetItem*>(item));
}

void* QListWidget_CurrentItem(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->currentItem();
}

void QListWidget_ConnectCurrentItemChanged(void* ptr)
{
	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));
}

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));
}

void QListWidget_ConnectCurrentRowChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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, char* currentText)
{
	static_cast<QListWidget*>(ptr)->currentTextChanged(QString(currentText));
}

void QListWidget_DropEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QListWidget_DropEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::dropEvent(static_cast<QDropEvent*>(event));
}

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));
}

char QListWidget_Event(void* ptr, void* e)
{
	return static_cast<QListWidget*>(ptr)->event(static_cast<QEvent*>(e));
}

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, char* label)
{
	static_cast<QListWidget*>(ptr)->insertItem(row, QString(label));
}

void QListWidget_InsertItems(void* ptr, int row, char* labels)
{
	static_cast<QListWidget*>(ptr)->insertItems(row, QString(labels).split("|", QString::SkipEmptyParts));
}

void* QListWidget_Item(void* ptr, int row)
{
	return static_cast<QListWidget*>(ptr)->item(row);
}

void QListWidget_ConnectItemActivated(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	QObject::connect(static_cast<QListWidget*>(ptr), static_cast<void (QListWidget::*)()>(&QListWidget::itemSelectionChanged), static_cast<MyQListWidget*>(ptr), static_cast<void (MyQListWidget::*)()>(&MyQListWidget::Signal_ItemSelectionChanged));
}

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));
}

char* QListWidget_MimeTypes(void* ptr)
{
	return const_cast<char*>(static_cast<QListWidget*>(ptr)->mimeTypes().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QListWidget_MimeTypesDefault(void* ptr)
{
	return const_cast<char*>(static_cast<QListWidget*>(ptr)->QListWidget::mimeTypes().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

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)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "scrollToItem", Q_ARG(QListWidgetItem*, static_cast<QListWidgetItem*>(item)), Q_ARG(QAbstractItemView::ScrollHint, static_cast<QAbstractItemView::ScrollHint>(hint)));
}

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_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_SetSelectionModel(void* ptr, void* selectionModel)
{
	static_cast<QListWidget*>(ptr)->setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

void QListWidget_SetSelectionModelDefault(void* ptr, void* selectionModel)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

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_CurrentChanged(void* ptr, void* current, void* previous)
{
	static_cast<QListWidget*>(ptr)->currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QListWidget_CurrentChangedDefault(void* ptr, void* current, void* previous)
{
	static_cast<QListWidget*>(ptr)->QListWidget::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QListWidget_DragLeaveEvent(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QListWidget_DragLeaveEventDefault(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->QListWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QListWidget_DragMoveEvent(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

void QListWidget_DragMoveEventDefault(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->QListWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

int QListWidget_HorizontalOffset(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->horizontalOffset();
}

int QListWidget_HorizontalOffsetDefault(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::horizontalOffset();
}

void* QListWidget_IndexAt(void* ptr, void* p)
{
	return new QModelIndex(static_cast<QListWidget*>(ptr)->indexAt(*static_cast<QPoint*>(p)));
}

void* QListWidget_IndexAtDefault(void* ptr, void* p)
{
	return new QModelIndex(static_cast<QListWidget*>(ptr)->QListWidget::indexAt(*static_cast<QPoint*>(p)));
}

char QListWidget_IsIndexHidden(void* ptr, void* index)
{
	return static_cast<QListWidget*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}

char QListWidget_IsIndexHiddenDefault(void* ptr, void* index)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::isIndexHidden(*static_cast<QModelIndex*>(index));
}

void QListWidget_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QListWidget_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->QListWidget::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QListWidget_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QListWidget_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->QListWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void* QListWidget_MoveCursor(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QListWidget*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void* QListWidget_MoveCursorDefault(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QListWidget*>(ptr)->QListWidget::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void QListWidget_PaintEvent(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->paintEvent(static_cast<QPaintEvent*>(e));
}

void QListWidget_PaintEventDefault(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->QListWidget::paintEvent(static_cast<QPaintEvent*>(e));
}

void QListWidget_ResizeEvent(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(e));
}

void QListWidget_ResizeEventDefault(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->QListWidget::resizeEvent(static_cast<QResizeEvent*>(e));
}

void QListWidget_RowsAboutToBeRemoved(void* ptr, void* parent, int start, int end)
{
	static_cast<QListWidget*>(ptr)->rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
}

void QListWidget_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QListWidget*>(ptr)->QListWidget::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
}

void QListWidget_RowsInserted(void* ptr, void* parent, int start, int end)
{
	static_cast<QListWidget*>(ptr)->rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
}

void QListWidget_RowsInsertedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QListWidget*>(ptr)->QListWidget::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
}

void QListWidget_ScrollTo(void* ptr, void* index, long long hint)
{
	static_cast<QListWidget*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QListWidget_ScrollToDefault(void* ptr, void* index, long long hint)
{
	static_cast<QListWidget*>(ptr)->QListWidget::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QListWidget_SelectionChanged(void* ptr, void* selected, void* deselected)
{
	static_cast<QListWidget*>(ptr)->selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

void QListWidget_SelectionChangedDefault(void* ptr, void* selected, void* deselected)
{
	static_cast<QListWidget*>(ptr)->QListWidget::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

void QListWidget_SetSelection(void* ptr, void* rect, long long command)
{
	static_cast<QListWidget*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QListWidget_SetSelectionDefault(void* ptr, void* rect, long long command)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QListWidget_StartDrag(void* ptr, long long supportedActions)
{
	static_cast<QListWidget*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QListWidget_StartDragDefault(void* ptr, long long supportedActions)
{
	static_cast<QListWidget*>(ptr)->QListWidget::startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QListWidget_UpdateGeometries(void* ptr)
{
	static_cast<QListWidget*>(ptr)->updateGeometries();
}

void QListWidget_UpdateGeometriesDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::updateGeometries();
}

int QListWidget_VerticalOffset(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->verticalOffset();
}

int QListWidget_VerticalOffsetDefault(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::verticalOffset();
}

void* QListWidget_ViewOptions(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QListWidget*>(ptr)->viewOptions());
}

void* QListWidget_ViewOptionsDefault(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QListWidget*>(ptr)->QListWidget::viewOptions());
}

void* QListWidget_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListWidget*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QListWidget_ViewportSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListWidget*>(ptr)->QListWidget::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QListWidget_VisualRect(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QListWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QListWidget_VisualRectDefault(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QListWidget*>(ptr)->QListWidget::visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QListWidget_VisualRegionForSelection(void* ptr, void* selection)
{
	return new QRegion(static_cast<QListWidget*>(ptr)->visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void* QListWidget_VisualRegionForSelectionDefault(void* ptr, void* selection)
{
	return new QRegion(static_cast<QListWidget*>(ptr)->QListWidget::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void QListWidget_WheelEvent(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QListWidget_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->QListWidget::wheelEvent(static_cast<QWheelEvent*>(e));
}

char QListWidget_ViewportEvent(void* ptr, void* event)
{
	return static_cast<QListWidget*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}

char QListWidget_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::viewportEvent(static_cast<QEvent*>(event));
}

void QListWidget_ClearSelection(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "clearSelection");
}

void QListWidget_ClearSelectionDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::clearSelection();
}

void QListWidget_CloseEditor(void* ptr, void* editor, long long hint)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "closeEditor", Q_ARG(QWidget*, static_cast<QWidget*>(editor)), Q_ARG(QAbstractItemDelegate::EndEditHint, static_cast<QAbstractItemDelegate::EndEditHint>(hint)));
}

void QListWidget_CloseEditorDefault(void* ptr, void* editor, long long hint)
{
	static_cast<QListWidget*>(ptr)->QListWidget::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
}

void QListWidget_CommitData(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "commitData", Q_ARG(QWidget*, static_cast<QWidget*>(editor)));
}

void QListWidget_CommitDataDefault(void* ptr, void* editor)
{
	static_cast<QListWidget*>(ptr)->QListWidget::commitData(static_cast<QWidget*>(editor));
}

void QListWidget_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QListWidget_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QListWidget_Edit(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "edit", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QListWidget_EditDefault(void* ptr, void* index)
{
	static_cast<QListWidget*>(ptr)->QListWidget::edit(*static_cast<QModelIndex*>(index));
}

char QListWidget_Edit2(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QListWidget*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

char QListWidget_Edit2Default(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

void QListWidget_EditorDestroyed(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "editorDestroyed", Q_ARG(QObject*, static_cast<QObject*>(editor)));
}

void QListWidget_EditorDestroyedDefault(void* ptr, void* editor)
{
	static_cast<QListWidget*>(ptr)->QListWidget::editorDestroyed(static_cast<QObject*>(editor));
}

void QListWidget_FocusInEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QListWidget_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QListWidget_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QListWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QListWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::focusNextPrevChild(next != 0);
}

void QListWidget_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QListWidget_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QListWidget_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QListWidget_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QListWidget_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QListWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QListWidget_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QListWidget*>(ptr)->QListWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QListWidget_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QListWidget_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QListWidget_KeyboardSearch(void* ptr, char* search)
{
	static_cast<QListWidget*>(ptr)->keyboardSearch(QString(search));
}

void QListWidget_KeyboardSearchDefault(void* ptr, char* search)
{
	static_cast<QListWidget*>(ptr)->QListWidget::keyboardSearch(QString(search));
}

void QListWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QListWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QListWidget_MousePressEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QListWidget_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QListWidget_Reset(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "reset");
}

void QListWidget_ResetDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::reset();
}

void QListWidget_ScrollToBottom(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "scrollToBottom");
}

void QListWidget_ScrollToBottomDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::scrollToBottom();
}

void QListWidget_ScrollToTop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "scrollToTop");
}

void QListWidget_ScrollToTopDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::scrollToTop();
}

void QListWidget_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "selectAll");
}

void QListWidget_SelectAllDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::selectAll();
}

long long QListWidget_SelectionCommand(void* ptr, void* index, void* event)
{
	return static_cast<QListWidget*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

long long QListWidget_SelectionCommandDefault(void* ptr, void* index, void* event)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

void QListWidget_SetCurrentIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setCurrentIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QListWidget_SetCurrentIndexDefault(void* ptr, void* index)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setCurrentIndex(*static_cast<QModelIndex*>(index));
}

void QListWidget_SetModel(void* ptr, void* model)
{
	static_cast<QListWidget*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}

void QListWidget_SetModelDefault(void* ptr, void* model)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setModel(static_cast<QAbstractItemModel*>(model));
}

void QListWidget_SetRootIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setRootIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QListWidget_SetRootIndexDefault(void* ptr, void* index)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setRootIndex(*static_cast<QModelIndex*>(index));
}

int QListWidget_SizeHintForColumn(void* ptr, int column)
{
	return static_cast<QListWidget*>(ptr)->sizeHintForColumn(column);
}

int QListWidget_SizeHintForColumnDefault(void* ptr, int column)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::sizeHintForColumn(column);
}

int QListWidget_SizeHintForRow(void* ptr, int row)
{
	return static_cast<QListWidget*>(ptr)->sizeHintForRow(row);
}

int QListWidget_SizeHintForRowDefault(void* ptr, int row)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::sizeHintForRow(row);
}

void QListWidget_Update(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "update", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QListWidget_UpdateDefault(void* ptr, void* index)
{
	static_cast<QListWidget*>(ptr)->QListWidget::update(*static_cast<QModelIndex*>(index));
}

void QListWidget_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QListWidget_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QListWidget*>(ptr)->QListWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void* QListWidget_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListWidget*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QListWidget_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListWidget*>(ptr)->QListWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QListWidget_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QListWidget*>(ptr)->scrollContentsBy(dx, dy);
}

void QListWidget_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QListWidget*>(ptr)->QListWidget::scrollContentsBy(dx, dy);
}

void QListWidget_SetupViewport(void* ptr, void* viewport)
{
	static_cast<QListWidget*>(ptr)->setupViewport(static_cast<QWidget*>(viewport));
}

void QListWidget_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setupViewport(static_cast<QWidget*>(viewport));
}

void* QListWidget_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListWidget*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QListWidget_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListWidget*>(ptr)->QListWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QListWidget_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QListWidget*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QListWidget_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QListWidget*>(ptr)->QListWidget::changeEvent(static_cast<QEvent*>(ev));
}

void QListWidget_ActionEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QListWidget_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::actionEvent(static_cast<QActionEvent*>(event));
}

void QListWidget_EnterEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QListWidget_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::enterEvent(static_cast<QEvent*>(event));
}

void QListWidget_HideEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QListWidget_HideEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::hideEvent(static_cast<QHideEvent*>(event));
}

void QListWidget_LeaveEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QListWidget_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::leaveEvent(static_cast<QEvent*>(event));
}

void QListWidget_MoveEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QListWidget_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::moveEvent(static_cast<QMoveEvent*>(event));
}

void QListWidget_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QListWidget_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setEnabled(vbo != 0);
}

void QListWidget_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QListWidget_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setStyleSheet(QString(styleSheet));
}

void QListWidget_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QListWidget_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setVisible(visible != 0);
}

void QListWidget_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QListWidget_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setWindowModified(vbo != 0);
}

void QListWidget_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QListWidget_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setWindowTitle(QString(vqs));
}

void QListWidget_ShowEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QListWidget_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::showEvent(static_cast<QShowEvent*>(event));
}

char QListWidget_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QListWidget_CloseDefault(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::close();
}

void QListWidget_CloseEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QListWidget_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::closeEvent(static_cast<QCloseEvent*>(event));
}

char QListWidget_HasHeightForWidth(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->hasHeightForWidth();
}

char QListWidget_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::hasHeightForWidth();
}

int QListWidget_HeightForWidth(void* ptr, int w)
{
	return static_cast<QListWidget*>(ptr)->heightForWidth(w);
}

int QListWidget_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::heightForWidth(w);
}

void QListWidget_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "hide");
}

void QListWidget_HideDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::hide();
}

void QListWidget_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QListWidget_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QListWidget_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "lower");
}

void QListWidget_LowerDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::lower();
}

char QListWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QListWidget*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QListWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QListWidget_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "raise");
}

void QListWidget_RaiseDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::raise();
}

void QListWidget_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "repaint");
}

void QListWidget_RepaintDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::repaint();
}

void QListWidget_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QListWidget_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setDisabled(disable != 0);
}

void QListWidget_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setFocus");
}

void QListWidget_SetFocus2Default(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setFocus();
}

void QListWidget_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QListWidget_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QListWidget*>(ptr)->QListWidget::setHidden(hidden != 0);
}

void QListWidget_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "show");
}

void QListWidget_ShowDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::show();
}

void QListWidget_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "showFullScreen");
}

void QListWidget_ShowFullScreenDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::showFullScreen();
}

void QListWidget_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "showMaximized");
}

void QListWidget_ShowMaximizedDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::showMaximized();
}

void QListWidget_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "showMinimized");
}

void QListWidget_ShowMinimizedDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::showMinimized();
}

void QListWidget_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "showNormal");
}

void QListWidget_ShowNormalDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::showNormal();
}

void QListWidget_TabletEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QListWidget_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QListWidget_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "updateMicroFocus");
}

void QListWidget_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::updateMicroFocus();
}

void QListWidget_ChildEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QListWidget_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::childEvent(static_cast<QChildEvent*>(event));
}

void QListWidget_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QListWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QListWidget_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QListWidget*>(ptr)->QListWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QListWidget_CustomEvent(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QListWidget_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QListWidget*>(ptr)->QListWidget::customEvent(static_cast<QEvent*>(event));
}

void QListWidget_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "deleteLater");
}

void QListWidget_DeleteLaterDefault(void* ptr)
{
	static_cast<QListWidget*>(ptr)->QListWidget::deleteLater();
}

void QListWidget_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QListWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QListWidget_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QListWidget*>(ptr)->QListWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QListWidget_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QListWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QListWidget_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QListWidget*>(ptr)->QListWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QListWidget_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QListWidget*>(ptr)->metaObject());
}

void* QListWidget_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QListWidget*>(ptr)->QListWidget::metaObject());
}

class MyQListWidgetItem: public QListWidgetItem
{
public:
	MyQListWidgetItem(QListWidget *parent, int type) : QListWidgetItem(parent, type) {};
	MyQListWidgetItem(const QIcon &icon, const QString &text, QListWidget *parent, int type) : QListWidgetItem(icon, text, parent, type) {};
	MyQListWidgetItem(const QString &text, QListWidget *parent, int type) : QListWidgetItem(text, parent, type) {};
	MyQListWidgetItem(const QListWidgetItem &other) : QListWidgetItem(other) {};
	QListWidgetItem * clone() const { return static_cast<QListWidgetItem*>(callbackQListWidgetItem_Clone(const_cast<MyQListWidgetItem*>(this))); };
	QVariant data(int role) const { return *static_cast<QVariant*>(callbackQListWidgetItem_Data(const_cast<MyQListWidgetItem*>(this), role)); };
	void setData(int role, const QVariant & value) { callbackQListWidgetItem_SetData(this, role, const_cast<QVariant*>(&value)); };
	 ~MyQListWidgetItem() { callbackQListWidgetItem_DestroyQListWidgetItem(this); };
};

void* QListWidgetItem_NewQListWidgetItem(void* parent, int ty)
{
	return new MyQListWidgetItem(static_cast<QListWidget*>(parent), ty);
}

void* QListWidgetItem_NewQListWidgetItem3(void* icon, char* text, void* parent, int ty)
{
	return new MyQListWidgetItem(*static_cast<QIcon*>(icon), QString(text), static_cast<QListWidget*>(parent), ty);
}

void* QListWidgetItem_NewQListWidgetItem2(char* text, void* parent, int ty)
{
	return new MyQListWidgetItem(QString(text), static_cast<QListWidget*>(parent), ty);
}

void QListWidgetItem_SetFlags(void* ptr, long long flags)
{
	static_cast<QListWidgetItem*>(ptr)->setFlags(static_cast<Qt::ItemFlag>(flags));
}

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_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_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, char* statusTip)
{
	static_cast<QListWidgetItem*>(ptr)->setStatusTip(QString(statusTip));
}

void QListWidgetItem_SetText(void* ptr, char* text)
{
	static_cast<QListWidgetItem*>(ptr)->setText(QString(text));
}

void QListWidgetItem_SetTextAlignment(void* ptr, int alignment)
{
	static_cast<QListWidgetItem*>(ptr)->setTextAlignment(alignment);
}

void QListWidgetItem_SetToolTip(void* ptr, char* toolTip)
{
	static_cast<QListWidgetItem*>(ptr)->setToolTip(QString(toolTip));
}

void QListWidgetItem_SetWhatsThis(void* ptr, char* whatsThis)
{
	static_cast<QListWidgetItem*>(ptr)->setWhatsThis(QString(whatsThis));
}

void* QListWidgetItem_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QListWidgetItem*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

char* QListWidgetItem_StatusTip(void* ptr)
{
	return const_cast<char*>(static_cast<QListWidgetItem*>(ptr)->statusTip().toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QListWidgetItem_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QListWidgetItem*>(ptr)->text().toUtf8().prepend("WHITESPACE").constData()+10);
}

int QListWidgetItem_TextAlignment(void* ptr)
{
	return static_cast<QListWidgetItem*>(ptr)->textAlignment();
}

char* QListWidgetItem_ToolTip(void* ptr)
{
	return const_cast<char*>(static_cast<QListWidgetItem*>(ptr)->toolTip().toUtf8().prepend("WHITESPACE").constData()+10);
}

int QListWidgetItem_Type(void* ptr)
{
	return static_cast<QListWidgetItem*>(ptr)->type();
}

char* QListWidgetItem_WhatsThis(void* ptr)
{
	return const_cast<char*>(static_cast<QListWidgetItem*>(ptr)->whatsThis().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QListWidgetItem_DestroyQListWidgetItem(void* ptr)
{
	static_cast<QListWidgetItem*>(ptr)->~QListWidgetItem();
}

void QListWidgetItem_DestroyQListWidgetItemDefault(void* ptr)
{

}

class MyQMacCocoaViewContainer: public QMacCocoaViewContainer
{
public:
	 ~MyQMacCocoaViewContainer() { callbackQMacCocoaViewContainer_DestroyQMacCocoaViewContainer(this); };
	void actionEvent(QActionEvent * event) { callbackQMacCocoaViewContainer_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQMacCocoaViewContainer_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMacCocoaViewContainer_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQMacCocoaViewContainer_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQMacCocoaViewContainer_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQMacCocoaViewContainer_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQMacCocoaViewContainer_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQMacCocoaViewContainer_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQMacCocoaViewContainer_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQMacCocoaViewContainer_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMacCocoaViewContainer_MinimumSizeHint(const_cast<MyQMacCocoaViewContainer*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQMacCocoaViewContainer_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQMacCocoaViewContainer_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQMacCocoaViewContainer_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQMacCocoaViewContainer_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQMacCocoaViewContainer_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQMacCocoaViewContainer_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQMacCocoaViewContainer_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQMacCocoaViewContainer_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQMacCocoaViewContainer_SizeHint(const_cast<MyQMacCocoaViewContainer*>(this))); };
	void changeEvent(QEvent * event) { callbackQMacCocoaViewContainer_ChangeEvent(this, event); };
	bool close() { return callbackQMacCocoaViewContainer_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQMacCocoaViewContainer_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQMacCocoaViewContainer_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQMacCocoaViewContainer_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQMacCocoaViewContainer_HasHeightForWidth(const_cast<MyQMacCocoaViewContainer*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQMacCocoaViewContainer_HeightForWidth(const_cast<MyQMacCocoaViewContainer*>(this), w); };
	void hide() { callbackQMacCocoaViewContainer_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQMacCocoaViewContainer_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMacCocoaViewContainer_InputMethodQuery(const_cast<MyQMacCocoaViewContainer*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQMacCocoaViewContainer_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQMacCocoaViewContainer_KeyReleaseEvent(this, event); };
	void lower() { callbackQMacCocoaViewContainer_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQMacCocoaViewContainer_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQMacCocoaViewContainer_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQMacCocoaViewContainer_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQMacCocoaViewContainer_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMacCocoaViewContainer_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQMacCocoaViewContainer_Raise(this); };
	void repaint() { callbackQMacCocoaViewContainer_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQMacCocoaViewContainer_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQMacCocoaViewContainer_SetDisabled(this, disable); };
	void setFocus() { callbackQMacCocoaViewContainer_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQMacCocoaViewContainer_SetHidden(this, hidden); };
	void show() { callbackQMacCocoaViewContainer_Show(this); };
	void showFullScreen() { callbackQMacCocoaViewContainer_ShowFullScreen(this); };
	void showMaximized() { callbackQMacCocoaViewContainer_ShowMaximized(this); };
	void showMinimized() { callbackQMacCocoaViewContainer_ShowMinimized(this); };
	void showNormal() { callbackQMacCocoaViewContainer_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQMacCocoaViewContainer_TabletEvent(this, event); };
	void update() { callbackQMacCocoaViewContainer_Update(this); };
	void updateMicroFocus() { callbackQMacCocoaViewContainer_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQMacCocoaViewContainer_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQMacCocoaViewContainer_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQMacCocoaViewContainer_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMacCocoaViewContainer_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMacCocoaViewContainer_CustomEvent(this, event); };
	void deleteLater() { callbackQMacCocoaViewContainer_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMacCocoaViewContainer_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMacCocoaViewContainer_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMacCocoaViewContainer_MetaObject(const_cast<MyQMacCocoaViewContainer*>(this))); };
};

void QMacCocoaViewContainer_DestroyQMacCocoaViewContainer(void* ptr)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->~QMacCocoaViewContainer();
}

void QMacCocoaViewContainer_DestroyQMacCocoaViewContainerDefault(void* ptr)
{
#ifdef Q_OS_OSX

#endif
}

void QMacCocoaViewContainer_ActionEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QMacCocoaViewContainer_ActionEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::actionEvent(static_cast<QActionEvent*>(event));
#endif
}

void QMacCocoaViewContainer_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMacCocoaViewContainer_DragEnterEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
#endif
}

void QMacCocoaViewContainer_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMacCocoaViewContainer_DragLeaveEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
#endif
}

void QMacCocoaViewContainer_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMacCocoaViewContainer_DragMoveEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
#endif
}

void QMacCocoaViewContainer_DropEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QMacCocoaViewContainer_DropEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::dropEvent(static_cast<QDropEvent*>(event));
#endif
}

void QMacCocoaViewContainer_EnterEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QMacCocoaViewContainer_EnterEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::enterEvent(static_cast<QEvent*>(event));
#endif
}

void QMacCocoaViewContainer_FocusInEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QMacCocoaViewContainer_FocusInEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::focusInEvent(static_cast<QFocusEvent*>(event));
#endif
}

void QMacCocoaViewContainer_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QMacCocoaViewContainer_FocusOutEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::focusOutEvent(static_cast<QFocusEvent*>(event));
#endif
}

void QMacCocoaViewContainer_HideEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QMacCocoaViewContainer_HideEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::hideEvent(static_cast<QHideEvent*>(event));
#endif
}

void QMacCocoaViewContainer_LeaveEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QMacCocoaViewContainer_LeaveEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::leaveEvent(static_cast<QEvent*>(event));
#endif
}

void* QMacCocoaViewContainer_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMacCocoaViewContainer*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMacCocoaViewContainer_MinimumSizeHintDefault(void* ptr)
{
#ifdef Q_OS_OSX
	return ({ QSize tmpValue = static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
#else
	return NULL;
#endif
}

void QMacCocoaViewContainer_MoveEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QMacCocoaViewContainer_MoveEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::moveEvent(static_cast<QMoveEvent*>(event));
#endif
}

void QMacCocoaViewContainer_PaintEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QMacCocoaViewContainer_PaintEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::paintEvent(static_cast<QPaintEvent*>(event));
#endif
}

void QMacCocoaViewContainer_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QMacCocoaViewContainer_SetEnabledDefault(void* ptr, char vbo)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::setEnabled(vbo != 0);
#endif
}

void QMacCocoaViewContainer_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QMacCocoaViewContainer_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::setStyleSheet(QString(styleSheet));
#endif
}

void QMacCocoaViewContainer_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QMacCocoaViewContainer_SetVisibleDefault(void* ptr, char visible)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::setVisible(visible != 0);
#endif
}

void QMacCocoaViewContainer_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QMacCocoaViewContainer_SetWindowModifiedDefault(void* ptr, char vbo)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::setWindowModified(vbo != 0);
#endif
}

void QMacCocoaViewContainer_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QMacCocoaViewContainer_SetWindowTitleDefault(void* ptr, char* vqs)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::setWindowTitle(QString(vqs));
#endif
}

void QMacCocoaViewContainer_ShowEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QMacCocoaViewContainer_ShowEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::showEvent(static_cast<QShowEvent*>(event));
#endif
}

void* QMacCocoaViewContainer_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMacCocoaViewContainer*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMacCocoaViewContainer_SizeHintDefault(void* ptr)
{
#ifdef Q_OS_OSX
	return ({ QSize tmpValue = static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
#else
	return NULL;
#endif
}

void QMacCocoaViewContainer_ChangeEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QMacCocoaViewContainer_ChangeEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::changeEvent(static_cast<QEvent*>(event));
#endif
}

char QMacCocoaViewContainer_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QMacCocoaViewContainer_CloseDefault(void* ptr)
{
#ifdef Q_OS_OSX
	return static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::close();
#else
	return false;
#endif
}

void QMacCocoaViewContainer_CloseEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QMacCocoaViewContainer_CloseEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::closeEvent(static_cast<QCloseEvent*>(event));
#endif
}

void QMacCocoaViewContainer_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QMacCocoaViewContainer_ContextMenuEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
#endif
}

char QMacCocoaViewContainer_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QMacCocoaViewContainer*>(ptr)->focusNextPrevChild(next != 0);
}

char QMacCocoaViewContainer_FocusNextPrevChildDefault(void* ptr, char next)
{
#ifdef Q_OS_OSX
	return static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::focusNextPrevChild(next != 0);
#else
	return false;
#endif
}

char QMacCocoaViewContainer_HasHeightForWidth(void* ptr)
{
	return static_cast<QMacCocoaViewContainer*>(ptr)->hasHeightForWidth();
}

char QMacCocoaViewContainer_HasHeightForWidthDefault(void* ptr)
{
#ifdef Q_OS_OSX
	return static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::hasHeightForWidth();
#else
	return false;
#endif
}

int QMacCocoaViewContainer_HeightForWidth(void* ptr, int w)
{
	return static_cast<QMacCocoaViewContainer*>(ptr)->heightForWidth(w);
}

int QMacCocoaViewContainer_HeightForWidthDefault(void* ptr, int w)
{
#ifdef Q_OS_OSX
	return static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::heightForWidth(w);
#else
	return 0;
#endif
}

void QMacCocoaViewContainer_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "hide");
}

void QMacCocoaViewContainer_HideDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::hide();
#endif
}

void QMacCocoaViewContainer_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QMacCocoaViewContainer_InputMethodEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
#endif
}

void* QMacCocoaViewContainer_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QMacCocoaViewContainer*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QMacCocoaViewContainer_InputMethodQueryDefault(void* ptr, long long query)
{
#ifdef Q_OS_OSX
	return new QVariant(static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
#else
	return NULL;
#endif
}

void QMacCocoaViewContainer_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QMacCocoaViewContainer_KeyPressEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::keyPressEvent(static_cast<QKeyEvent*>(event));
#endif
}

void QMacCocoaViewContainer_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMacCocoaViewContainer_KeyReleaseEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::keyReleaseEvent(static_cast<QKeyEvent*>(event));
#endif
}

void QMacCocoaViewContainer_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "lower");
}

void QMacCocoaViewContainer_LowerDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::lower();
#endif
}

void QMacCocoaViewContainer_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QMacCocoaViewContainer_MouseDoubleClickEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
#endif
}

void QMacCocoaViewContainer_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QMacCocoaViewContainer_MouseMoveEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::mouseMoveEvent(static_cast<QMouseEvent*>(event));
#endif
}

void QMacCocoaViewContainer_MousePressEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QMacCocoaViewContainer_MousePressEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::mousePressEvent(static_cast<QMouseEvent*>(event));
#endif
}

void QMacCocoaViewContainer_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QMacCocoaViewContainer_MouseReleaseEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
#endif
}

char QMacCocoaViewContainer_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMacCocoaViewContainer*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QMacCocoaViewContainer_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
#ifdef Q_OS_OSX
	return static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
#else
	return false;
#endif
}

void QMacCocoaViewContainer_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "raise");
}

void QMacCocoaViewContainer_RaiseDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::raise();
#endif
}

void QMacCocoaViewContainer_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "repaint");
}

void QMacCocoaViewContainer_RepaintDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::repaint();
#endif
}

void QMacCocoaViewContainer_ResizeEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QMacCocoaViewContainer_ResizeEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::resizeEvent(static_cast<QResizeEvent*>(event));
#endif
}

void QMacCocoaViewContainer_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QMacCocoaViewContainer_SetDisabledDefault(void* ptr, char disable)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::setDisabled(disable != 0);
#endif
}

void QMacCocoaViewContainer_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "setFocus");
}

void QMacCocoaViewContainer_SetFocus2Default(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::setFocus();
#endif
}

void QMacCocoaViewContainer_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QMacCocoaViewContainer_SetHiddenDefault(void* ptr, char hidden)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::setHidden(hidden != 0);
#endif
}

void QMacCocoaViewContainer_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "show");
}

void QMacCocoaViewContainer_ShowDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::show();
#endif
}

void QMacCocoaViewContainer_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "showFullScreen");
}

void QMacCocoaViewContainer_ShowFullScreenDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::showFullScreen();
#endif
}

void QMacCocoaViewContainer_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "showMaximized");
}

void QMacCocoaViewContainer_ShowMaximizedDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::showMaximized();
#endif
}

void QMacCocoaViewContainer_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "showMinimized");
}

void QMacCocoaViewContainer_ShowMinimizedDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::showMinimized();
#endif
}

void QMacCocoaViewContainer_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "showNormal");
}

void QMacCocoaViewContainer_ShowNormalDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::showNormal();
#endif
}

void QMacCocoaViewContainer_TabletEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMacCocoaViewContainer_TabletEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::tabletEvent(static_cast<QTabletEvent*>(event));
#endif
}

void QMacCocoaViewContainer_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "update");
}

void QMacCocoaViewContainer_UpdateDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::update();
#endif
}

void QMacCocoaViewContainer_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "updateMicroFocus");
}

void QMacCocoaViewContainer_UpdateMicroFocusDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::updateMicroFocus();
#endif
}

void QMacCocoaViewContainer_WheelEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QMacCocoaViewContainer_WheelEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::wheelEvent(static_cast<QWheelEvent*>(event));
#endif
}

void QMacCocoaViewContainer_TimerEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QMacCocoaViewContainer_TimerEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::timerEvent(static_cast<QTimerEvent*>(event));
#endif
}

void QMacCocoaViewContainer_ChildEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QMacCocoaViewContainer_ChildEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::childEvent(static_cast<QChildEvent*>(event));
#endif
}

void QMacCocoaViewContainer_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMacCocoaViewContainer_ConnectNotifyDefault(void* ptr, void* sign)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::connectNotify(*static_cast<QMetaMethod*>(sign));
#endif
}

void QMacCocoaViewContainer_CustomEvent(void* ptr, void* event)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QMacCocoaViewContainer_CustomEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::customEvent(static_cast<QEvent*>(event));
#endif
}

void QMacCocoaViewContainer_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "deleteLater");
}

void QMacCocoaViewContainer_DeleteLaterDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::deleteLater();
#endif
}

void QMacCocoaViewContainer_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QMacCocoaViewContainer*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMacCocoaViewContainer_DisconnectNotifyDefault(void* ptr, void* sign)
{
#ifdef Q_OS_OSX
	static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::disconnectNotify(*static_cast<QMetaMethod*>(sign));
#endif
}

char QMacCocoaViewContainer_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QMacCocoaViewContainer*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QMacCocoaViewContainer_EventFilterDefault(void* ptr, void* watched, void* event)
{
#ifdef Q_OS_OSX
	return static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
#else
	return false;
#endif
}

void* QMacCocoaViewContainer_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMacCocoaViewContainer*>(ptr)->metaObject());
}

void* QMacCocoaViewContainer_MetaObjectDefault(void* ptr)
{
#ifdef Q_OS_OSX
	return const_cast<QMetaObject*>(static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::metaObject());
#else
	return NULL;
#endif
}

class MyQMacNativeWidget: public QMacNativeWidget
{
public:
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQMacNativeWidget_SizeHint(const_cast<MyQMacNativeWidget*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQMacNativeWidget_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQMacNativeWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMacNativeWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQMacNativeWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQMacNativeWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQMacNativeWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQMacNativeWidget_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQMacNativeWidget_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQMacNativeWidget_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQMacNativeWidget_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMacNativeWidget_MinimumSizeHint(const_cast<MyQMacNativeWidget*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQMacNativeWidget_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQMacNativeWidget_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQMacNativeWidget_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQMacNativeWidget_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQMacNativeWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQMacNativeWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQMacNativeWidget_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQMacNativeWidget_ShowEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQMacNativeWidget_ChangeEvent(this, event); };
	bool close() { return callbackQMacNativeWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQMacNativeWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQMacNativeWidget_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQMacNativeWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQMacNativeWidget_HasHeightForWidth(const_cast<MyQMacNativeWidget*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQMacNativeWidget_HeightForWidth(const_cast<MyQMacNativeWidget*>(this), w); };
	void hide() { callbackQMacNativeWidget_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQMacNativeWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMacNativeWidget_InputMethodQuery(const_cast<MyQMacNativeWidget*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQMacNativeWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQMacNativeWidget_KeyReleaseEvent(this, event); };
	void lower() { callbackQMacNativeWidget_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQMacNativeWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQMacNativeWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQMacNativeWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQMacNativeWidget_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMacNativeWidget_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQMacNativeWidget_Raise(this); };
	void repaint() { callbackQMacNativeWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQMacNativeWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQMacNativeWidget_SetDisabled(this, disable); };
	void setFocus() { callbackQMacNativeWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQMacNativeWidget_SetHidden(this, hidden); };
	void show() { callbackQMacNativeWidget_Show(this); };
	void showFullScreen() { callbackQMacNativeWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQMacNativeWidget_ShowMaximized(this); };
	void showMinimized() { callbackQMacNativeWidget_ShowMinimized(this); };
	void showNormal() { callbackQMacNativeWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQMacNativeWidget_TabletEvent(this, event); };
	void update() { callbackQMacNativeWidget_Update(this); };
	void updateMicroFocus() { callbackQMacNativeWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQMacNativeWidget_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQMacNativeWidget_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQMacNativeWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMacNativeWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMacNativeWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQMacNativeWidget_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMacNativeWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMacNativeWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMacNativeWidget_MetaObject(const_cast<MyQMacNativeWidget*>(this))); };
};

char QMacNativeWidget_Event(void* ptr, void* ev)
{
	return static_cast<QMacNativeWidget*>(ptr)->event(static_cast<QEvent*>(ev));
}

void* QMacNativeWidget_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMacNativeWidget*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMacNativeWidget_SizeHintDefault(void* ptr)
{
#ifdef Q_OS_OSX
	return ({ QSize tmpValue = static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
#else
	return NULL;
#endif
}

void QMacNativeWidget_DestroyQMacNativeWidget(void* ptr)
{
	static_cast<QMacNativeWidget*>(ptr)->~QMacNativeWidget();
}

void QMacNativeWidget_ActionEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QMacNativeWidget_ActionEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::actionEvent(static_cast<QActionEvent*>(event));
#endif
}

void QMacNativeWidget_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMacNativeWidget_DragEnterEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
#endif
}

void QMacNativeWidget_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMacNativeWidget_DragLeaveEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
#endif
}

void QMacNativeWidget_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMacNativeWidget_DragMoveEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
#endif
}

void QMacNativeWidget_DropEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QMacNativeWidget_DropEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::dropEvent(static_cast<QDropEvent*>(event));
#endif
}

void QMacNativeWidget_EnterEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QMacNativeWidget_EnterEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::enterEvent(static_cast<QEvent*>(event));
#endif
}

void QMacNativeWidget_FocusInEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QMacNativeWidget_FocusInEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::focusInEvent(static_cast<QFocusEvent*>(event));
#endif
}

void QMacNativeWidget_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QMacNativeWidget_FocusOutEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
#endif
}

void QMacNativeWidget_HideEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QMacNativeWidget_HideEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::hideEvent(static_cast<QHideEvent*>(event));
#endif
}

void QMacNativeWidget_LeaveEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QMacNativeWidget_LeaveEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::leaveEvent(static_cast<QEvent*>(event));
#endif
}

void* QMacNativeWidget_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMacNativeWidget*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMacNativeWidget_MinimumSizeHintDefault(void* ptr)
{
#ifdef Q_OS_OSX
	return ({ QSize tmpValue = static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
#else
	return NULL;
#endif
}

void QMacNativeWidget_MoveEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QMacNativeWidget_MoveEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::moveEvent(static_cast<QMoveEvent*>(event));
#endif
}

void QMacNativeWidget_PaintEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QMacNativeWidget_PaintEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::paintEvent(static_cast<QPaintEvent*>(event));
#endif
}

void QMacNativeWidget_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QMacNativeWidget_SetEnabledDefault(void* ptr, char vbo)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::setEnabled(vbo != 0);
#endif
}

void QMacNativeWidget_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QMacNativeWidget_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::setStyleSheet(QString(styleSheet));
#endif
}

void QMacNativeWidget_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QMacNativeWidget_SetVisibleDefault(void* ptr, char visible)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::setVisible(visible != 0);
#endif
}

void QMacNativeWidget_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QMacNativeWidget_SetWindowModifiedDefault(void* ptr, char vbo)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::setWindowModified(vbo != 0);
#endif
}

void QMacNativeWidget_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QMacNativeWidget_SetWindowTitleDefault(void* ptr, char* vqs)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::setWindowTitle(QString(vqs));
#endif
}

void QMacNativeWidget_ShowEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QMacNativeWidget_ShowEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::showEvent(static_cast<QShowEvent*>(event));
#endif
}

void QMacNativeWidget_ChangeEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QMacNativeWidget_ChangeEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::changeEvent(static_cast<QEvent*>(event));
#endif
}

char QMacNativeWidget_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QMacNativeWidget_CloseDefault(void* ptr)
{
#ifdef Q_OS_OSX
	return static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::close();
#else
	return false;
#endif
}

void QMacNativeWidget_CloseEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QMacNativeWidget_CloseEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::closeEvent(static_cast<QCloseEvent*>(event));
#endif
}

void QMacNativeWidget_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QMacNativeWidget_ContextMenuEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
#endif
}

char QMacNativeWidget_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QMacNativeWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QMacNativeWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
#ifdef Q_OS_OSX
	return static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::focusNextPrevChild(next != 0);
#else
	return false;
#endif
}

char QMacNativeWidget_HasHeightForWidth(void* ptr)
{
	return static_cast<QMacNativeWidget*>(ptr)->hasHeightForWidth();
}

char QMacNativeWidget_HasHeightForWidthDefault(void* ptr)
{
#ifdef Q_OS_OSX
	return static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::hasHeightForWidth();
#else
	return false;
#endif
}

int QMacNativeWidget_HeightForWidth(void* ptr, int w)
{
	return static_cast<QMacNativeWidget*>(ptr)->heightForWidth(w);
}

int QMacNativeWidget_HeightForWidthDefault(void* ptr, int w)
{
#ifdef Q_OS_OSX
	return static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::heightForWidth(w);
#else
	return 0;
#endif
}

void QMacNativeWidget_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "hide");
}

void QMacNativeWidget_HideDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::hide();
#endif
}

void QMacNativeWidget_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QMacNativeWidget_InputMethodEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
#endif
}

void* QMacNativeWidget_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QMacNativeWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QMacNativeWidget_InputMethodQueryDefault(void* ptr, long long query)
{
#ifdef Q_OS_OSX
	return new QVariant(static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
#else
	return NULL;
#endif
}

void QMacNativeWidget_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QMacNativeWidget_KeyPressEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
#endif
}

void QMacNativeWidget_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMacNativeWidget_KeyReleaseEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
#endif
}

void QMacNativeWidget_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "lower");
}

void QMacNativeWidget_LowerDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::lower();
#endif
}

void QMacNativeWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QMacNativeWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
#endif
}

void QMacNativeWidget_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QMacNativeWidget_MouseMoveEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
#endif
}

void QMacNativeWidget_MousePressEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QMacNativeWidget_MousePressEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
#endif
}

void QMacNativeWidget_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QMacNativeWidget_MouseReleaseEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
#endif
}

char QMacNativeWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMacNativeWidget*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QMacNativeWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
#ifdef Q_OS_OSX
	return static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
#else
	return false;
#endif
}

void QMacNativeWidget_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "raise");
}

void QMacNativeWidget_RaiseDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::raise();
#endif
}

void QMacNativeWidget_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "repaint");
}

void QMacNativeWidget_RepaintDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::repaint();
#endif
}

void QMacNativeWidget_ResizeEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QMacNativeWidget_ResizeEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::resizeEvent(static_cast<QResizeEvent*>(event));
#endif
}

void QMacNativeWidget_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QMacNativeWidget_SetDisabledDefault(void* ptr, char disable)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::setDisabled(disable != 0);
#endif
}

void QMacNativeWidget_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "setFocus");
}

void QMacNativeWidget_SetFocus2Default(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::setFocus();
#endif
}

void QMacNativeWidget_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QMacNativeWidget_SetHiddenDefault(void* ptr, char hidden)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::setHidden(hidden != 0);
#endif
}

void QMacNativeWidget_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "show");
}

void QMacNativeWidget_ShowDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::show();
#endif
}

void QMacNativeWidget_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "showFullScreen");
}

void QMacNativeWidget_ShowFullScreenDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::showFullScreen();
#endif
}

void QMacNativeWidget_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "showMaximized");
}

void QMacNativeWidget_ShowMaximizedDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::showMaximized();
#endif
}

void QMacNativeWidget_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "showMinimized");
}

void QMacNativeWidget_ShowMinimizedDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::showMinimized();
#endif
}

void QMacNativeWidget_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "showNormal");
}

void QMacNativeWidget_ShowNormalDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::showNormal();
#endif
}

void QMacNativeWidget_TabletEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMacNativeWidget_TabletEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::tabletEvent(static_cast<QTabletEvent*>(event));
#endif
}

void QMacNativeWidget_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "update");
}

void QMacNativeWidget_UpdateDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::update();
#endif
}

void QMacNativeWidget_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "updateMicroFocus");
}

void QMacNativeWidget_UpdateMicroFocusDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::updateMicroFocus();
#endif
}

void QMacNativeWidget_WheelEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QMacNativeWidget_WheelEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::wheelEvent(static_cast<QWheelEvent*>(event));
#endif
}

void QMacNativeWidget_TimerEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QMacNativeWidget_TimerEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::timerEvent(static_cast<QTimerEvent*>(event));
#endif
}

void QMacNativeWidget_ChildEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QMacNativeWidget_ChildEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::childEvent(static_cast<QChildEvent*>(event));
#endif
}

void QMacNativeWidget_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QMacNativeWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMacNativeWidget_ConnectNotifyDefault(void* ptr, void* sign)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
#endif
}

void QMacNativeWidget_CustomEvent(void* ptr, void* event)
{
	static_cast<QMacNativeWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QMacNativeWidget_CustomEventDefault(void* ptr, void* event)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::customEvent(static_cast<QEvent*>(event));
#endif
}

void QMacNativeWidget_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "deleteLater");
}

void QMacNativeWidget_DeleteLaterDefault(void* ptr)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::deleteLater();
#endif
}

void QMacNativeWidget_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QMacNativeWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMacNativeWidget_DisconnectNotifyDefault(void* ptr, void* sign)
{
#ifdef Q_OS_OSX
	static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
#endif
}

char QMacNativeWidget_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QMacNativeWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QMacNativeWidget_EventFilterDefault(void* ptr, void* watched, void* event)
{
#ifdef Q_OS_OSX
	return static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
#else
	return false;
#endif
}

void* QMacNativeWidget_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMacNativeWidget*>(ptr)->metaObject());
}

void* QMacNativeWidget_MetaObjectDefault(void* ptr)
{
#ifdef Q_OS_OSX
	return const_cast<QMetaObject*>(static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::metaObject());
#else
	return NULL;
#endif
}

class MyQMainWindow: public QMainWindow
{
public:
	MyQMainWindow(QWidget *parent, Qt::WindowFlags flags) : QMainWindow(parent, flags) {};
	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 contextMenuEvent(QContextMenuEvent * event) { callbackQMainWindow_ContextMenuEvent(this, event); };
	QMenu * createPopupMenu() { return static_cast<QMenu*>(callbackQMainWindow_CreatePopupMenu(this)); };
	void Signal_IconSizeChanged(const QSize & iconSize) { callbackQMainWindow_IconSizeChanged(this, const_cast<QSize*>(&iconSize)); };
	void Signal_ToolButtonStyleChanged(Qt::ToolButtonStyle toolButtonStyle) { callbackQMainWindow_ToolButtonStyleChanged(this, toolButtonStyle); };
	void actionEvent(QActionEvent * event) { callbackQMainWindow_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQMainWindow_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMainWindow_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQMainWindow_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQMainWindow_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQMainWindow_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQMainWindow_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQMainWindow_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQMainWindow_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQMainWindow_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMainWindow_MinimumSizeHint(const_cast<MyQMainWindow*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQMainWindow_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQMainWindow_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQMainWindow_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQMainWindow_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQMainWindow_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQMainWindow_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQMainWindow_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQMainWindow_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQMainWindow_SizeHint(const_cast<MyQMainWindow*>(this))); };
	void changeEvent(QEvent * event) { callbackQMainWindow_ChangeEvent(this, event); };
	bool close() { return callbackQMainWindow_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQMainWindow_CloseEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQMainWindow_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQMainWindow_HasHeightForWidth(const_cast<MyQMainWindow*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQMainWindow_HeightForWidth(const_cast<MyQMainWindow*>(this), w); };
	void hide() { callbackQMainWindow_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQMainWindow_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMainWindow_InputMethodQuery(const_cast<MyQMainWindow*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQMainWindow_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQMainWindow_KeyReleaseEvent(this, event); };
	void lower() { callbackQMainWindow_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQMainWindow_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQMainWindow_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQMainWindow_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQMainWindow_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMainWindow_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQMainWindow_Raise(this); };
	void repaint() { callbackQMainWindow_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQMainWindow_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQMainWindow_SetDisabled(this, disable); };
	void setFocus() { callbackQMainWindow_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQMainWindow_SetHidden(this, hidden); };
	void show() { callbackQMainWindow_Show(this); };
	void showFullScreen() { callbackQMainWindow_ShowFullScreen(this); };
	void showMaximized() { callbackQMainWindow_ShowMaximized(this); };
	void showMinimized() { callbackQMainWindow_ShowMinimized(this); };
	void showNormal() { callbackQMainWindow_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQMainWindow_TabletEvent(this, event); };
	void update() { callbackQMainWindow_Update(this); };
	void updateMicroFocus() { callbackQMainWindow_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQMainWindow_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQMainWindow_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQMainWindow_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMainWindow_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMainWindow_CustomEvent(this, event); };
	void deleteLater() { callbackQMainWindow_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMainWindow_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMainWindow_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMainWindow_MetaObject(const_cast<MyQMainWindow*>(this))); };
};

long long QMainWindow_DockOptions(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->dockOptions();
}

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()); });
}

char QMainWindow_IsAnimated(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->isAnimated();
}

char QMainWindow_IsDockNestingEnabled(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->isDockNestingEnabled();
}

void QMainWindow_SetAnimated(void* ptr, char enabled)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setAnimated", Q_ARG(bool, enabled != 0));
}

void QMainWindow_SetDockNestingEnabled(void* ptr, char enabled)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setDockNestingEnabled", Q_ARG(bool, 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_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_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));
}

long long QMainWindow_TabShape(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->tabShape();
}

void QMainWindow_TabifyDockWidget(void* ptr, void* first, void* second)
{
	static_cast<QMainWindow*>(ptr)->tabifyDockWidget(static_cast<QDockWidget*>(first), static_cast<QDockWidget*>(second));
}

long long QMainWindow_ToolButtonStyle(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->toolButtonStyle();
}

char QMainWindow_UnifiedTitleAndToolBarOnMac(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->unifiedTitleAndToolBarOnMac();
}

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_AddToolBar3(void* ptr, char* title)
{
	return static_cast<QMainWindow*>(ptr)->addToolBar(QString(title));
}

void QMainWindow_AddToolBar2(void* ptr, void* toolbar)
{
	static_cast<QMainWindow*>(ptr)->addToolBar(static_cast<QToolBar*>(toolbar));
}

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_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();
}

void QMainWindow_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QMainWindow_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

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_DockWidgetArea(void* ptr, void* dockwidget)
{
	return static_cast<QMainWindow*>(ptr)->dockWidgetArea(static_cast<QDockWidget*>(dockwidget));
}

char QMainWindow_Event(void* ptr, void* event)
{
	return static_cast<QMainWindow*>(ptr)->event(static_cast<QEvent*>(event));
}

void QMainWindow_ConnectIconSizeChanged(void* ptr)
{
	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));
}

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));
}

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));
}

char QMainWindow_RestoreDockWidget(void* ptr, void* dockwidget)
{
	return static_cast<QMainWindow*>(ptr)->restoreDockWidget(static_cast<QDockWidget*>(dockwidget));
}

char QMainWindow_RestoreState(void* ptr, char* state, int version)
{
	return static_cast<QMainWindow*>(ptr)->restoreState(QByteArray::fromHex(QString(state).toUtf8()), version);
}

char* QMainWindow_SaveState(void* ptr, int version)
{
	return const_cast<char*>(static_cast<QMainWindow*>(ptr)->saveState(version).toHex().prepend("WHITESPACE").constData()+10);
}

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_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_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));
}

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));
}

void QMainWindow_ConnectToolButtonStyleChanged(void* ptr)
{
	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));
}

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));
}

void QMainWindow_DestroyQMainWindow(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->~QMainWindow();
}

void QMainWindow_ActionEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QMainWindow_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::actionEvent(static_cast<QActionEvent*>(event));
}

void QMainWindow_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMainWindow_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMainWindow_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMainWindow_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMainWindow_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMainWindow_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMainWindow_DropEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QMainWindow_DropEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::dropEvent(static_cast<QDropEvent*>(event));
}

void QMainWindow_EnterEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QMainWindow_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::enterEvent(static_cast<QEvent*>(event));
}

void QMainWindow_FocusInEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QMainWindow_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QMainWindow_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QMainWindow_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QMainWindow_HideEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QMainWindow_HideEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::hideEvent(static_cast<QHideEvent*>(event));
}

void QMainWindow_LeaveEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QMainWindow_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::leaveEvent(static_cast<QEvent*>(event));
}

void* QMainWindow_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMainWindow*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMainWindow_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMainWindow*>(ptr)->QMainWindow::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMainWindow_MoveEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QMainWindow_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::moveEvent(static_cast<QMoveEvent*>(event));
}

void QMainWindow_PaintEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QMainWindow_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::paintEvent(static_cast<QPaintEvent*>(event));
}

void QMainWindow_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QMainWindow_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::setEnabled(vbo != 0);
}

void QMainWindow_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QMainWindow_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::setStyleSheet(QString(styleSheet));
}

void QMainWindow_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QMainWindow_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::setVisible(visible != 0);
}

void QMainWindow_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QMainWindow_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::setWindowModified(vbo != 0);
}

void QMainWindow_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QMainWindow_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::setWindowTitle(QString(vqs));
}

void QMainWindow_ShowEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QMainWindow_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::showEvent(static_cast<QShowEvent*>(event));
}

void* QMainWindow_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMainWindow*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMainWindow_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMainWindow*>(ptr)->QMainWindow::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMainWindow_ChangeEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QMainWindow_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::changeEvent(static_cast<QEvent*>(event));
}

char QMainWindow_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QMainWindow_CloseDefault(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->QMainWindow::close();
}

void QMainWindow_CloseEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QMainWindow_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::closeEvent(static_cast<QCloseEvent*>(event));
}

char QMainWindow_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QMainWindow*>(ptr)->focusNextPrevChild(next != 0);
}

char QMainWindow_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QMainWindow*>(ptr)->QMainWindow::focusNextPrevChild(next != 0);
}

char QMainWindow_HasHeightForWidth(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->hasHeightForWidth();
}

char QMainWindow_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QMainWindow*>(ptr)->QMainWindow::hasHeightForWidth();
}

int QMainWindow_HeightForWidth(void* ptr, int w)
{
	return static_cast<QMainWindow*>(ptr)->heightForWidth(w);
}

int QMainWindow_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QMainWindow*>(ptr)->QMainWindow::heightForWidth(w);
}

void QMainWindow_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "hide");
}

void QMainWindow_HideDefault(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::hide();
}

void QMainWindow_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QMainWindow_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QMainWindow_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QMainWindow*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QMainWindow_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QMainWindow*>(ptr)->QMainWindow::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QMainWindow_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QMainWindow_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QMainWindow_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMainWindow_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMainWindow_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "lower");
}

void QMainWindow_LowerDefault(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::lower();
}

void QMainWindow_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QMainWindow_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QMainWindow_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QMainWindow_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QMainWindow_MousePressEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QMainWindow_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QMainWindow_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QMainWindow_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QMainWindow_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMainWindow*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QMainWindow_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMainWindow*>(ptr)->QMainWindow::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QMainWindow_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "raise");
}

void QMainWindow_RaiseDefault(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::raise();
}

void QMainWindow_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "repaint");
}

void QMainWindow_RepaintDefault(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::repaint();
}

void QMainWindow_ResizeEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QMainWindow_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QMainWindow_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QMainWindow_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::setDisabled(disable != 0);
}

void QMainWindow_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setFocus");
}

void QMainWindow_SetFocus2Default(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::setFocus();
}

void QMainWindow_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QMainWindow_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::setHidden(hidden != 0);
}

void QMainWindow_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "show");
}

void QMainWindow_ShowDefault(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::show();
}

void QMainWindow_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "showFullScreen");
}

void QMainWindow_ShowFullScreenDefault(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::showFullScreen();
}

void QMainWindow_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "showMaximized");
}

void QMainWindow_ShowMaximizedDefault(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::showMaximized();
}

void QMainWindow_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "showMinimized");
}

void QMainWindow_ShowMinimizedDefault(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::showMinimized();
}

void QMainWindow_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "showNormal");
}

void QMainWindow_ShowNormalDefault(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::showNormal();
}

void QMainWindow_TabletEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMainWindow_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMainWindow_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "update");
}

void QMainWindow_UpdateDefault(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::update();
}

void QMainWindow_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "updateMicroFocus");
}

void QMainWindow_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::updateMicroFocus();
}

void QMainWindow_WheelEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QMainWindow_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QMainWindow_TimerEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QMainWindow_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::timerEvent(static_cast<QTimerEvent*>(event));
}

void QMainWindow_ChildEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QMainWindow_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::childEvent(static_cast<QChildEvent*>(event));
}

void QMainWindow_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QMainWindow*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMainWindow_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMainWindow_CustomEvent(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QMainWindow_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::customEvent(static_cast<QEvent*>(event));
}

void QMainWindow_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "deleteLater");
}

void QMainWindow_DeleteLaterDefault(void* ptr)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::deleteLater();
}

void QMainWindow_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QMainWindow*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMainWindow_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMainWindow*>(ptr)->QMainWindow::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QMainWindow_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QMainWindow*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QMainWindow_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QMainWindow*>(ptr)->QMainWindow::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QMainWindow_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMainWindow*>(ptr)->metaObject());
}

void* QMainWindow_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMainWindow*>(ptr)->QMainWindow::metaObject());
}

class MyQMdiArea: public QMdiArea
{
public:
	MyQMdiArea(QWidget *parent) : QMdiArea(parent) {};
	void activateNextSubWindow() { callbackQMdiArea_ActivateNextSubWindow(this); };
	void activatePreviousSubWindow() { callbackQMdiArea_ActivatePreviousSubWindow(this); };
	void cascadeSubWindows() { callbackQMdiArea_CascadeSubWindows(this); };
	void closeActiveSubWindow() { callbackQMdiArea_CloseActiveSubWindow(this); };
	void closeAllSubWindows() { callbackQMdiArea_CloseAllSubWindows(this); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMdiArea_MinimumSizeHint(const_cast<MyQMdiArea*>(this))); };
	void paintEvent(QPaintEvent * paintEvent) { callbackQMdiArea_PaintEvent(this, paintEvent); };
	void resizeEvent(QResizeEvent * resizeEvent) { callbackQMdiArea_ResizeEvent(this, resizeEvent); };
	void scrollContentsBy(int dx, int dy) { callbackQMdiArea_ScrollContentsBy(this, dx, dy); };
	void setActiveSubWindow(QMdiSubWindow * window) { callbackQMdiArea_SetActiveSubWindow(this, window); };
	void setupViewport(QWidget * viewport) { callbackQMdiArea_SetupViewport(this, viewport); };
	void showEvent(QShowEvent * showEvent) { callbackQMdiArea_ShowEvent(this, showEvent); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQMdiArea_SizeHint(const_cast<MyQMdiArea*>(this))); };
	void Signal_SubWindowActivated(QMdiSubWindow * window) { callbackQMdiArea_SubWindowActivated(this, window); };
	void tileSubWindows() { callbackQMdiArea_TileSubWindows(this); };
	bool viewportEvent(QEvent * event) { return callbackQMdiArea_ViewportEvent(this, event) != 0; };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQMdiArea_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMdiArea_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQMdiArea_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQMdiArea_DropEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQMdiArea_ContextMenuEvent(this, e); };
	void keyPressEvent(QKeyEvent * e) { callbackQMdiArea_KeyPressEvent(this, e); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQMdiArea_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQMdiArea_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQMdiArea_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQMdiArea_MouseReleaseEvent(this, e); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQMdiArea_ViewportSizeHint(const_cast<MyQMdiArea*>(this))); };
	void wheelEvent(QWheelEvent * e) { callbackQMdiArea_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQMdiArea_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQMdiArea_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQMdiArea_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQMdiArea_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQMdiArea_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQMdiArea_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQMdiArea_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQMdiArea_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQMdiArea_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQMdiArea_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQMdiArea_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQMdiArea_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQMdiArea_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQMdiArea_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQMdiArea_CloseEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQMdiArea_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQMdiArea_HasHeightForWidth(const_cast<MyQMdiArea*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQMdiArea_HeightForWidth(const_cast<MyQMdiArea*>(this), w); };
	void hide() { callbackQMdiArea_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQMdiArea_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMdiArea_InputMethodQuery(const_cast<MyQMdiArea*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQMdiArea_KeyReleaseEvent(this, event); };
	void lower() { callbackQMdiArea_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMdiArea_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQMdiArea_Raise(this); };
	void repaint() { callbackQMdiArea_Repaint(this); };
	void setDisabled(bool disable) { callbackQMdiArea_SetDisabled(this, disable); };
	void setFocus() { callbackQMdiArea_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQMdiArea_SetHidden(this, hidden); };
	void show() { callbackQMdiArea_Show(this); };
	void showFullScreen() { callbackQMdiArea_ShowFullScreen(this); };
	void showMaximized() { callbackQMdiArea_ShowMaximized(this); };
	void showMinimized() { callbackQMdiArea_ShowMinimized(this); };
	void showNormal() { callbackQMdiArea_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQMdiArea_TabletEvent(this, event); };
	void update() { callbackQMdiArea_Update(this); };
	void updateMicroFocus() { callbackQMdiArea_UpdateMicroFocus(this); };
	void connectNotify(const QMetaMethod & sign) { callbackQMdiArea_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMdiArea_CustomEvent(this, event); };
	void deleteLater() { callbackQMdiArea_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMdiArea_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMdiArea_MetaObject(const_cast<MyQMdiArea*>(this))); };
};

long long QMdiArea_ActivationOrder(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->activationOrder();
}

void* QMdiArea_Background(void* ptr)
{
	return new QBrush(static_cast<QMdiArea*>(ptr)->background());
}

char QMdiArea_DocumentMode(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->documentMode();
}

void QMdiArea_SetActivationOrder(void* ptr, long long order)
{
	static_cast<QMdiArea*>(ptr)->setActivationOrder(static_cast<QMdiArea::WindowOrder>(order));
}

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_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));
}

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();
}

long long QMdiArea_ViewMode(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->viewMode();
}

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_ActivatePreviousSubWindow(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "activatePreviousSubWindow");
}

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_CascadeSubWindows(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "cascadeSubWindows");
}

void QMdiArea_ChildEvent(void* ptr, void* childEvent)
{
	static_cast<QMdiArea*>(ptr)->childEvent(static_cast<QChildEvent*>(childEvent));
}

void QMdiArea_CloseActiveSubWindow(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "closeActiveSubWindow");
}

void QMdiArea_CloseAllSubWindows(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "closeAllSubWindows");
}

void* QMdiArea_CurrentSubWindow(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->currentSubWindow();
}

char QMdiArea_Event(void* ptr, void* event)
{
	return static_cast<QMdiArea*>(ptr)->event(static_cast<QEvent*>(event));
}

char QMdiArea_EventFilter(void* ptr, void* object, void* event)
{
	return static_cast<QMdiArea*>(ptr)->eventFilter(static_cast<QObject*>(object), static_cast<QEvent*>(event));
}

void* QMdiArea_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMdiArea*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMdiArea_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMdiArea*>(ptr)->QMdiArea::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMdiArea_PaintEvent(void* ptr, void* paintEvent)
{
	static_cast<QMdiArea*>(ptr)->paintEvent(static_cast<QPaintEvent*>(paintEvent));
}

void QMdiArea_PaintEventDefault(void* ptr, void* paintEvent)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::paintEvent(static_cast<QPaintEvent*>(paintEvent));
}

void QMdiArea_RemoveSubWindow(void* ptr, void* widget)
{
	static_cast<QMdiArea*>(ptr)->removeSubWindow(static_cast<QWidget*>(widget));
}

void QMdiArea_ResizeEvent(void* ptr, void* resizeEvent)
{
	static_cast<QMdiArea*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(resizeEvent));
}

void QMdiArea_ResizeEventDefault(void* ptr, void* resizeEvent)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::resizeEvent(static_cast<QResizeEvent*>(resizeEvent));
}

void QMdiArea_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QMdiArea*>(ptr)->scrollContentsBy(dx, dy);
}

void QMdiArea_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::scrollContentsBy(dx, dy);
}

void QMdiArea_SetActiveSubWindow(void* ptr, void* window)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setActiveSubWindow", Q_ARG(QMdiSubWindow*, static_cast<QMdiSubWindow*>(window)));
}

void QMdiArea_SetOption(void* ptr, long long option, char on)
{
	static_cast<QMdiArea*>(ptr)->setOption(static_cast<QMdiArea::AreaOption>(option), on != 0);
}

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_ShowEvent(void* ptr, void* showEvent)
{
	static_cast<QMdiArea*>(ptr)->showEvent(static_cast<QShowEvent*>(showEvent));
}

void QMdiArea_ShowEventDefault(void* ptr, void* showEvent)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::showEvent(static_cast<QShowEvent*>(showEvent));
}

void* QMdiArea_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMdiArea*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMdiArea_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMdiArea*>(ptr)->QMdiArea::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMdiArea_ConnectSubWindowActivated(void* ptr)
{
	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));
}

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));
}

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_TimerEvent(void* ptr, void* timerEvent)
{
	static_cast<QMdiArea*>(ptr)->timerEvent(static_cast<QTimerEvent*>(timerEvent));
}

char QMdiArea_ViewportEvent(void* ptr, void* event)
{
	return static_cast<QMdiArea*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}

char QMdiArea_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QMdiArea*>(ptr)->QMdiArea::viewportEvent(static_cast<QEvent*>(event));
}

void QMdiArea_DestroyQMdiArea(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->~QMdiArea();
}

void QMdiArea_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMdiArea_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMdiArea_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMdiArea_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMdiArea_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMdiArea_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMdiArea_DropEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QMdiArea_DropEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::dropEvent(static_cast<QDropEvent*>(event));
}

void QMdiArea_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QMdiArea_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QMdiArea_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QMdiArea_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QMdiArea_MouseDoubleClickEvent(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QMdiArea_MouseDoubleClickEventDefault(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QMdiArea_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QMdiArea_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QMdiArea_MousePressEvent(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QMdiArea_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QMdiArea_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QMdiArea_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void* QMdiArea_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMdiArea*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMdiArea_ViewportSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMdiArea*>(ptr)->QMdiArea::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMdiArea_WheelEvent(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QMdiArea_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QMdiArea_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QMdiArea*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QMdiArea_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::changeEvent(static_cast<QEvent*>(ev));
}

void QMdiArea_ActionEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QMdiArea_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::actionEvent(static_cast<QActionEvent*>(event));
}

void QMdiArea_EnterEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QMdiArea_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::enterEvent(static_cast<QEvent*>(event));
}

void QMdiArea_FocusInEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QMdiArea_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QMdiArea_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QMdiArea_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QMdiArea_HideEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QMdiArea_HideEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::hideEvent(static_cast<QHideEvent*>(event));
}

void QMdiArea_LeaveEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QMdiArea_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::leaveEvent(static_cast<QEvent*>(event));
}

void QMdiArea_MoveEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QMdiArea_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::moveEvent(static_cast<QMoveEvent*>(event));
}

void QMdiArea_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QMdiArea_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::setEnabled(vbo != 0);
}

void QMdiArea_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QMdiArea_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::setStyleSheet(QString(styleSheet));
}

void QMdiArea_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QMdiArea_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::setVisible(visible != 0);
}

void QMdiArea_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QMdiArea_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::setWindowModified(vbo != 0);
}

void QMdiArea_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QMdiArea_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::setWindowTitle(QString(vqs));
}

char QMdiArea_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QMdiArea_CloseDefault(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->QMdiArea::close();
}

void QMdiArea_CloseEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QMdiArea_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::closeEvent(static_cast<QCloseEvent*>(event));
}

char QMdiArea_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QMdiArea*>(ptr)->focusNextPrevChild(next != 0);
}

char QMdiArea_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QMdiArea*>(ptr)->QMdiArea::focusNextPrevChild(next != 0);
}

char QMdiArea_HasHeightForWidth(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->hasHeightForWidth();
}

char QMdiArea_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QMdiArea*>(ptr)->QMdiArea::hasHeightForWidth();
}

int QMdiArea_HeightForWidth(void* ptr, int w)
{
	return static_cast<QMdiArea*>(ptr)->heightForWidth(w);
}

int QMdiArea_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QMdiArea*>(ptr)->QMdiArea::heightForWidth(w);
}

void QMdiArea_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "hide");
}

void QMdiArea_HideDefault(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::hide();
}

void QMdiArea_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QMdiArea_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QMdiArea_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QMdiArea*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QMdiArea_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QMdiArea*>(ptr)->QMdiArea::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QMdiArea_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMdiArea_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMdiArea_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "lower");
}

void QMdiArea_LowerDefault(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::lower();
}

char QMdiArea_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMdiArea*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QMdiArea_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMdiArea*>(ptr)->QMdiArea::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QMdiArea_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "raise");
}

void QMdiArea_RaiseDefault(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::raise();
}

void QMdiArea_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "repaint");
}

void QMdiArea_RepaintDefault(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::repaint();
}

void QMdiArea_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QMdiArea_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::setDisabled(disable != 0);
}

void QMdiArea_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setFocus");
}

void QMdiArea_SetFocus2Default(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::setFocus();
}

void QMdiArea_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QMdiArea_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::setHidden(hidden != 0);
}

void QMdiArea_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "show");
}

void QMdiArea_ShowDefault(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::show();
}

void QMdiArea_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "showFullScreen");
}

void QMdiArea_ShowFullScreenDefault(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::showFullScreen();
}

void QMdiArea_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "showMaximized");
}

void QMdiArea_ShowMaximizedDefault(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::showMaximized();
}

void QMdiArea_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "showMinimized");
}

void QMdiArea_ShowMinimizedDefault(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::showMinimized();
}

void QMdiArea_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "showNormal");
}

void QMdiArea_ShowNormalDefault(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::showNormal();
}

void QMdiArea_TabletEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMdiArea_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMdiArea_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "update");
}

void QMdiArea_UpdateDefault(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::update();
}

void QMdiArea_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "updateMicroFocus");
}

void QMdiArea_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::updateMicroFocus();
}

void QMdiArea_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QMdiArea*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMdiArea_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMdiArea_CustomEvent(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QMdiArea_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::customEvent(static_cast<QEvent*>(event));
}

void QMdiArea_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "deleteLater");
}

void QMdiArea_DeleteLaterDefault(void* ptr)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::deleteLater();
}

void QMdiArea_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QMdiArea*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMdiArea_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMdiArea*>(ptr)->QMdiArea::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void* QMdiArea_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMdiArea*>(ptr)->metaObject());
}

void* QMdiArea_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMdiArea*>(ptr)->QMdiArea::metaObject());
}

class MyQMdiSubWindow: public QMdiSubWindow
{
public:
	MyQMdiSubWindow(QWidget *parent, Qt::WindowFlags flags) : QMdiSubWindow(parent, flags) {};
	void Signal_AboutToActivate() { callbackQMdiSubWindow_AboutToActivate(this); };
	void changeEvent(QEvent * changeEvent) { callbackQMdiSubWindow_ChangeEvent(this, changeEvent); };
	void closeEvent(QCloseEvent * closeEvent) { callbackQMdiSubWindow_CloseEvent(this, closeEvent); };
	void contextMenuEvent(QContextMenuEvent * contextMenuEvent) { callbackQMdiSubWindow_ContextMenuEvent(this, contextMenuEvent); };
	void focusInEvent(QFocusEvent * focusInEvent) { callbackQMdiSubWindow_FocusInEvent(this, focusInEvent); };
	void focusOutEvent(QFocusEvent * focusOutEvent) { callbackQMdiSubWindow_FocusOutEvent(this, focusOutEvent); };
	void hideEvent(QHideEvent * hideEvent) { callbackQMdiSubWindow_HideEvent(this, hideEvent); };
	void keyPressEvent(QKeyEvent * keyEvent) { callbackQMdiSubWindow_KeyPressEvent(this, keyEvent); };
	void leaveEvent(QEvent * leaveEvent) { callbackQMdiSubWindow_LeaveEvent(this, leaveEvent); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMdiSubWindow_MinimumSizeHint(const_cast<MyQMdiSubWindow*>(this))); };
	void mouseDoubleClickEvent(QMouseEvent * mouseEvent) { callbackQMdiSubWindow_MouseDoubleClickEvent(this, mouseEvent); };
	void mouseMoveEvent(QMouseEvent * mouseEvent) { callbackQMdiSubWindow_MouseMoveEvent(this, mouseEvent); };
	void mousePressEvent(QMouseEvent * mouseEvent) { callbackQMdiSubWindow_MousePressEvent(this, mouseEvent); };
	void mouseReleaseEvent(QMouseEvent * mouseEvent) { callbackQMdiSubWindow_MouseReleaseEvent(this, mouseEvent); };
	void moveEvent(QMoveEvent * moveEvent) { callbackQMdiSubWindow_MoveEvent(this, moveEvent); };
	void paintEvent(QPaintEvent * paintEvent) { callbackQMdiSubWindow_PaintEvent(this, paintEvent); };
	void resizeEvent(QResizeEvent * resizeEvent) { callbackQMdiSubWindow_ResizeEvent(this, resizeEvent); };
	void showEvent(QShowEvent * showEvent) { callbackQMdiSubWindow_ShowEvent(this, showEvent); };
	void showShaded() { callbackQMdiSubWindow_ShowShaded(this); };
	void showSystemMenu() { callbackQMdiSubWindow_ShowSystemMenu(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQMdiSubWindow_SizeHint(const_cast<MyQMdiSubWindow*>(this))); };
	void Signal_WindowStateChanged(Qt::WindowStates oldState, Qt::WindowStates newState) { callbackQMdiSubWindow_WindowStateChanged(this, oldState, newState); };
	void actionEvent(QActionEvent * event) { callbackQMdiSubWindow_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQMdiSubWindow_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMdiSubWindow_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQMdiSubWindow_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQMdiSubWindow_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQMdiSubWindow_EnterEvent(this, event); };
	void setEnabled(bool vbo) { callbackQMdiSubWindow_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQMdiSubWindow_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQMdiSubWindow_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQMdiSubWindow_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQMdiSubWindow_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQMdiSubWindow_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQMdiSubWindow_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQMdiSubWindow_HasHeightForWidth(const_cast<MyQMdiSubWindow*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQMdiSubWindow_HeightForWidth(const_cast<MyQMdiSubWindow*>(this), w); };
	void hide() { callbackQMdiSubWindow_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQMdiSubWindow_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMdiSubWindow_InputMethodQuery(const_cast<MyQMdiSubWindow*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQMdiSubWindow_KeyReleaseEvent(this, event); };
	void lower() { callbackQMdiSubWindow_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMdiSubWindow_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQMdiSubWindow_Raise(this); };
	void repaint() { callbackQMdiSubWindow_Repaint(this); };
	void setDisabled(bool disable) { callbackQMdiSubWindow_SetDisabled(this, disable); };
	void setFocus() { callbackQMdiSubWindow_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQMdiSubWindow_SetHidden(this, hidden); };
	void show() { callbackQMdiSubWindow_Show(this); };
	void showFullScreen() { callbackQMdiSubWindow_ShowFullScreen(this); };
	void showMaximized() { callbackQMdiSubWindow_ShowMaximized(this); };
	void showMinimized() { callbackQMdiSubWindow_ShowMinimized(this); };
	void showNormal() { callbackQMdiSubWindow_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQMdiSubWindow_TabletEvent(this, event); };
	void update() { callbackQMdiSubWindow_Update(this); };
	void updateMicroFocus() { callbackQMdiSubWindow_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQMdiSubWindow_WheelEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMdiSubWindow_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMdiSubWindow_CustomEvent(this, event); };
	void deleteLater() { callbackQMdiSubWindow_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMdiSubWindow_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMdiSubWindow_MetaObject(const_cast<MyQMdiSubWindow*>(this))); };
};

int QMdiSubWindow_KeyboardPageStep(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->keyboardPageStep();
}

int QMdiSubWindow_KeyboardSingleStep(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->keyboardSingleStep();
}

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_NewQMdiSubWindow(void* parent, long long flags)
{
	return new MyQMdiSubWindow(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}

void QMdiSubWindow_ConnectAboutToActivate(void* ptr)
{
	QObject::connect(static_cast<QMdiSubWindow*>(ptr), static_cast<void (QMdiSubWindow::*)()>(&QMdiSubWindow::aboutToActivate), static_cast<MyQMdiSubWindow*>(ptr), static_cast<void (MyQMdiSubWindow::*)()>(&MyQMdiSubWindow::Signal_AboutToActivate));
}

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();
}

void QMdiSubWindow_ChangeEvent(void* ptr, void* changeEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->changeEvent(static_cast<QEvent*>(changeEvent));
}

void QMdiSubWindow_ChangeEventDefault(void* ptr, void* changeEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::changeEvent(static_cast<QEvent*>(changeEvent));
}

void QMdiSubWindow_ChildEvent(void* ptr, void* childEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->childEvent(static_cast<QChildEvent*>(childEvent));
}

void QMdiSubWindow_CloseEvent(void* ptr, void* closeEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->closeEvent(static_cast<QCloseEvent*>(closeEvent));
}

void QMdiSubWindow_CloseEventDefault(void* ptr, void* closeEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::closeEvent(static_cast<QCloseEvent*>(closeEvent));
}

void QMdiSubWindow_ContextMenuEvent(void* ptr, void* contextMenuEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(contextMenuEvent));
}

void QMdiSubWindow_ContextMenuEventDefault(void* ptr, void* contextMenuEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::contextMenuEvent(static_cast<QContextMenuEvent*>(contextMenuEvent));
}

char QMdiSubWindow_Event(void* ptr, void* event)
{
	return static_cast<QMdiSubWindow*>(ptr)->event(static_cast<QEvent*>(event));
}

char QMdiSubWindow_EventFilter(void* ptr, void* object, void* event)
{
	return static_cast<QMdiSubWindow*>(ptr)->eventFilter(static_cast<QObject*>(object), static_cast<QEvent*>(event));
}

void QMdiSubWindow_FocusInEvent(void* ptr, void* focusInEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(focusInEvent));
}

void QMdiSubWindow_FocusInEventDefault(void* ptr, void* focusInEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::focusInEvent(static_cast<QFocusEvent*>(focusInEvent));
}

void QMdiSubWindow_FocusOutEvent(void* ptr, void* focusOutEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(focusOutEvent));
}

void QMdiSubWindow_FocusOutEventDefault(void* ptr, void* focusOutEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::focusOutEvent(static_cast<QFocusEvent*>(focusOutEvent));
}

void QMdiSubWindow_HideEvent(void* ptr, void* hideEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->hideEvent(static_cast<QHideEvent*>(hideEvent));
}

void QMdiSubWindow_HideEventDefault(void* ptr, void* hideEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::hideEvent(static_cast<QHideEvent*>(hideEvent));
}

char QMdiSubWindow_IsShaded(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->isShaded();
}

void QMdiSubWindow_KeyPressEvent(void* ptr, void* keyEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(keyEvent));
}

void QMdiSubWindow_KeyPressEventDefault(void* ptr, void* keyEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::keyPressEvent(static_cast<QKeyEvent*>(keyEvent));
}

void QMdiSubWindow_LeaveEvent(void* ptr, void* leaveEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->leaveEvent(static_cast<QEvent*>(leaveEvent));
}

void QMdiSubWindow_LeaveEventDefault(void* ptr, void* leaveEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::leaveEvent(static_cast<QEvent*>(leaveEvent));
}

void* QMdiSubWindow_MdiArea(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->mdiArea();
}

void* QMdiSubWindow_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMdiSubWindow*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMdiSubWindow_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMdiSubWindow_MouseDoubleClickEvent(void* ptr, void* mouseEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(mouseEvent));
}

void QMdiSubWindow_MouseDoubleClickEventDefault(void* ptr, void* mouseEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::mouseDoubleClickEvent(static_cast<QMouseEvent*>(mouseEvent));
}

void QMdiSubWindow_MouseMoveEvent(void* ptr, void* mouseEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(mouseEvent));
}

void QMdiSubWindow_MouseMoveEventDefault(void* ptr, void* mouseEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::mouseMoveEvent(static_cast<QMouseEvent*>(mouseEvent));
}

void QMdiSubWindow_MousePressEvent(void* ptr, void* mouseEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(mouseEvent));
}

void QMdiSubWindow_MousePressEventDefault(void* ptr, void* mouseEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::mousePressEvent(static_cast<QMouseEvent*>(mouseEvent));
}

void QMdiSubWindow_MouseReleaseEvent(void* ptr, void* mouseEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(mouseEvent));
}

void QMdiSubWindow_MouseReleaseEventDefault(void* ptr, void* mouseEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::mouseReleaseEvent(static_cast<QMouseEvent*>(mouseEvent));
}

void QMdiSubWindow_MoveEvent(void* ptr, void* moveEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->moveEvent(static_cast<QMoveEvent*>(moveEvent));
}

void QMdiSubWindow_MoveEventDefault(void* ptr, void* moveEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::moveEvent(static_cast<QMoveEvent*>(moveEvent));
}

void QMdiSubWindow_PaintEvent(void* ptr, void* paintEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->paintEvent(static_cast<QPaintEvent*>(paintEvent));
}

void QMdiSubWindow_PaintEventDefault(void* ptr, void* paintEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::paintEvent(static_cast<QPaintEvent*>(paintEvent));
}

void QMdiSubWindow_ResizeEvent(void* ptr, void* resizeEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(resizeEvent));
}

void QMdiSubWindow_ResizeEventDefault(void* ptr, void* resizeEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::resizeEvent(static_cast<QResizeEvent*>(resizeEvent));
}

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_ShowEvent(void* ptr, void* showEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->showEvent(static_cast<QShowEvent*>(showEvent));
}

void QMdiSubWindow_ShowEventDefault(void* ptr, void* showEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::showEvent(static_cast<QShowEvent*>(showEvent));
}

void QMdiSubWindow_ShowShaded(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "showShaded");
}

void QMdiSubWindow_ShowSystemMenu(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "showSystemMenu");
}

void* QMdiSubWindow_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMdiSubWindow*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMdiSubWindow_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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_TimerEvent(void* ptr, void* timerEvent)
{
	static_cast<QMdiSubWindow*>(ptr)->timerEvent(static_cast<QTimerEvent*>(timerEvent));
}

void* QMdiSubWindow_Widget(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->widget();
}

void QMdiSubWindow_ConnectWindowStateChanged(void* ptr)
{
	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));
}

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_ActionEvent(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QMdiSubWindow_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::actionEvent(static_cast<QActionEvent*>(event));
}

void QMdiSubWindow_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMdiSubWindow_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMdiSubWindow_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMdiSubWindow_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMdiSubWindow_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMdiSubWindow_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMdiSubWindow_DropEvent(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QMdiSubWindow_DropEventDefault(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::dropEvent(static_cast<QDropEvent*>(event));
}

void QMdiSubWindow_EnterEvent(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QMdiSubWindow_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::enterEvent(static_cast<QEvent*>(event));
}

void QMdiSubWindow_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QMdiSubWindow_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setEnabled(vbo != 0);
}

void QMdiSubWindow_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QMdiSubWindow_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setStyleSheet(QString(styleSheet));
}

void QMdiSubWindow_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QMdiSubWindow_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setVisible(visible != 0);
}

void QMdiSubWindow_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QMdiSubWindow_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setWindowModified(vbo != 0);
}

void QMdiSubWindow_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QMdiSubWindow_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setWindowTitle(QString(vqs));
}

char QMdiSubWindow_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QMdiSubWindow_CloseDefault(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::close();
}

char QMdiSubWindow_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QMdiSubWindow*>(ptr)->focusNextPrevChild(next != 0);
}

char QMdiSubWindow_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::focusNextPrevChild(next != 0);
}

char QMdiSubWindow_HasHeightForWidth(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->hasHeightForWidth();
}

char QMdiSubWindow_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::hasHeightForWidth();
}

int QMdiSubWindow_HeightForWidth(void* ptr, int w)
{
	return static_cast<QMdiSubWindow*>(ptr)->heightForWidth(w);
}

int QMdiSubWindow_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::heightForWidth(w);
}

void QMdiSubWindow_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "hide");
}

void QMdiSubWindow_HideDefault(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::hide();
}

void QMdiSubWindow_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QMdiSubWindow_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QMdiSubWindow_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QMdiSubWindow*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QMdiSubWindow_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QMdiSubWindow_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMdiSubWindow_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMdiSubWindow_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "lower");
}

void QMdiSubWindow_LowerDefault(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::lower();
}

char QMdiSubWindow_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMdiSubWindow*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QMdiSubWindow_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QMdiSubWindow_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "raise");
}

void QMdiSubWindow_RaiseDefault(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::raise();
}

void QMdiSubWindow_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "repaint");
}

void QMdiSubWindow_RepaintDefault(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::repaint();
}

void QMdiSubWindow_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QMdiSubWindow_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setDisabled(disable != 0);
}

void QMdiSubWindow_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "setFocus");
}

void QMdiSubWindow_SetFocus2Default(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setFocus();
}

void QMdiSubWindow_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QMdiSubWindow_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setHidden(hidden != 0);
}

void QMdiSubWindow_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "show");
}

void QMdiSubWindow_ShowDefault(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::show();
}

void QMdiSubWindow_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "showFullScreen");
}

void QMdiSubWindow_ShowFullScreenDefault(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::showFullScreen();
}

void QMdiSubWindow_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "showMaximized");
}

void QMdiSubWindow_ShowMaximizedDefault(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::showMaximized();
}

void QMdiSubWindow_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "showMinimized");
}

void QMdiSubWindow_ShowMinimizedDefault(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::showMinimized();
}

void QMdiSubWindow_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "showNormal");
}

void QMdiSubWindow_ShowNormalDefault(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::showNormal();
}

void QMdiSubWindow_TabletEvent(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMdiSubWindow_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMdiSubWindow_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "update");
}

void QMdiSubWindow_UpdateDefault(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::update();
}

void QMdiSubWindow_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "updateMicroFocus");
}

void QMdiSubWindow_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::updateMicroFocus();
}

void QMdiSubWindow_WheelEvent(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QMdiSubWindow_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QMdiSubWindow_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QMdiSubWindow*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMdiSubWindow_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMdiSubWindow_CustomEvent(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QMdiSubWindow_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::customEvent(static_cast<QEvent*>(event));
}

void QMdiSubWindow_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "deleteLater");
}

void QMdiSubWindow_DeleteLaterDefault(void* ptr)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::deleteLater();
}

void QMdiSubWindow_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QMdiSubWindow*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMdiSubWindow_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void* QMdiSubWindow_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMdiSubWindow*>(ptr)->metaObject());
}

void* QMdiSubWindow_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::metaObject());
}

class MyQMenu: public QMenu
{
public:
	MyQMenu(QWidget *parent) : QMenu(parent) {};
	MyQMenu(const QString &title, QWidget *parent) : QMenu(title, parent) {};
	void Signal_AboutToHide() { callbackQMenu_AboutToHide(this); };
	void Signal_AboutToShow() { callbackQMenu_AboutToShow(this); };
	void actionEvent(QActionEvent * e) { callbackQMenu_ActionEvent(this, e); };
	void changeEvent(QEvent * e) { callbackQMenu_ChangeEvent(this, e); };
	void enterEvent(QEvent * vqe) { callbackQMenu_EnterEvent(this, vqe); };
	bool focusNextPrevChild(bool next) { return callbackQMenu_FocusNextPrevChild(this, next) != 0; };
	void hideEvent(QHideEvent * vqh) { callbackQMenu_HideEvent(this, vqh); };
	void Signal_Hovered(QAction * action) { callbackQMenu_Hovered(this, action); };
	void keyPressEvent(QKeyEvent * e) { callbackQMenu_KeyPressEvent(this, e); };
	void leaveEvent(QEvent * vqe) { callbackQMenu_LeaveEvent(this, vqe); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQMenu_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQMenu_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQMenu_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQMenu_PaintEvent(this, e); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQMenu_SizeHint(const_cast<MyQMenu*>(this))); };
	void Signal_Triggered(QAction * action) { callbackQMenu_Triggered(this, action); };
	void wheelEvent(QWheelEvent * e) { callbackQMenu_WheelEvent(this, e); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQMenu_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMenu_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQMenu_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQMenu_DropEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQMenu_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQMenu_FocusOutEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMenu_MinimumSizeHint(const_cast<MyQMenu*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQMenu_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQMenu_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQMenu_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQMenu_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQMenu_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQMenu_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQMenu_ShowEvent(this, event); };
	bool close() { return callbackQMenu_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQMenu_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQMenu_ContextMenuEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQMenu_HasHeightForWidth(const_cast<MyQMenu*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQMenu_HeightForWidth(const_cast<MyQMenu*>(this), w); };
	void hide() { callbackQMenu_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQMenu_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMenu_InputMethodQuery(const_cast<MyQMenu*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQMenu_KeyReleaseEvent(this, event); };
	void lower() { callbackQMenu_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQMenu_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMenu_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQMenu_Raise(this); };
	void repaint() { callbackQMenu_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQMenu_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQMenu_SetDisabled(this, disable); };
	void setFocus() { callbackQMenu_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQMenu_SetHidden(this, hidden); };
	void show() { callbackQMenu_Show(this); };
	void showFullScreen() { callbackQMenu_ShowFullScreen(this); };
	void showMaximized() { callbackQMenu_ShowMaximized(this); };
	void showMinimized() { callbackQMenu_ShowMinimized(this); };
	void showNormal() { callbackQMenu_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQMenu_TabletEvent(this, event); };
	void update() { callbackQMenu_Update(this); };
	void updateMicroFocus() { callbackQMenu_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQMenu_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMenu_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMenu_CustomEvent(this, event); };
	void deleteLater() { callbackQMenu_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMenu_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMenu_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMenu_MetaObject(const_cast<MyQMenu*>(this))); };
};

void* QMenu_Icon(void* ptr)
{
	return new QIcon(static_cast<QMenu*>(ptr)->icon());
}

char QMenu_IsTearOffEnabled(void* ptr)
{
	return static_cast<QMenu*>(ptr)->isTearOffEnabled();
}

char QMenu_SeparatorsCollapsible(void* ptr)
{
	return static_cast<QMenu*>(ptr)->separatorsCollapsible();
}

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, char* title)
{
	static_cast<QMenu*>(ptr)->setTitle(QString(title));
}

void QMenu_SetToolTipsVisible(void* ptr, char visible)
{
	static_cast<QMenu*>(ptr)->setToolTipsVisible(visible != 0);
}

char* QMenu_Title(void* ptr)
{
	return const_cast<char*>(static_cast<QMenu*>(ptr)->title().toUtf8().prepend("WHITESPACE").constData()+10);
}

char QMenu_ToolTipsVisible(void* ptr)
{
	return static_cast<QMenu*>(ptr)->toolTipsVisible();
}

void* QMenu_NewQMenu(void* parent)
{
	return new MyQMenu(static_cast<QWidget*>(parent));
}

void* QMenu_NewQMenu2(char* title, void* parent)
{
	return new MyQMenu(QString(title), static_cast<QWidget*>(parent));
}

void QMenu_ConnectAboutToHide(void* ptr)
{
	QObject::connect(static_cast<QMenu*>(ptr), static_cast<void (QMenu::*)()>(&QMenu::aboutToHide), static_cast<MyQMenu*>(ptr), static_cast<void (MyQMenu::*)()>(&MyQMenu::Signal_AboutToHide));
}

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)
{
	QObject::connect(static_cast<QMenu*>(ptr), static_cast<void (QMenu::*)()>(&QMenu::aboutToShow), static_cast<MyQMenu*>(ptr), static_cast<void (MyQMenu::*)()>(&MyQMenu::Signal_AboutToShow));
}

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_ActionEvent(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->actionEvent(static_cast<QActionEvent*>(e));
}

void QMenu_ActionEventDefault(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->QMenu::actionEvent(static_cast<QActionEvent*>(e));
}

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_AddAction2(void* ptr, void* icon, char* text)
{
	return static_cast<QMenu*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString(text));
}

void* QMenu_AddAction4(void* ptr, void* icon, char* text, void* receiver, char* member, void* shortcut)
{
	return static_cast<QMenu*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString(text), static_cast<QObject*>(receiver), const_cast<const char*>(member), *static_cast<QKeySequence*>(shortcut));
}

void* QMenu_AddAction(void* ptr, char* text)
{
	return static_cast<QMenu*>(ptr)->addAction(QString(text));
}

void* QMenu_AddAction3(void* ptr, char* text, void* receiver, char* member, void* shortcut)
{
	return static_cast<QMenu*>(ptr)->addAction(QString(text), 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_AddMenu3(void* ptr, void* icon, char* title)
{
	return static_cast<QMenu*>(ptr)->addMenu(*static_cast<QIcon*>(icon), QString(title));
}

void* QMenu_AddMenu2(void* ptr, char* title)
{
	return static_cast<QMenu*>(ptr)->addMenu(QString(title));
}

void* QMenu_AddSection2(void* ptr, void* icon, char* text)
{
	return static_cast<QMenu*>(ptr)->addSection(*static_cast<QIcon*>(icon), QString(text));
}

void* QMenu_AddSection(void* ptr, char* text)
{
	return static_cast<QMenu*>(ptr)->addSection(QString(text));
}

void* QMenu_AddSeparator(void* ptr)
{
	return static_cast<QMenu*>(ptr)->addSeparator();
}

void QMenu_ChangeEvent(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QMenu_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->QMenu::changeEvent(static_cast<QEvent*>(e));
}

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_EnterEvent(void* ptr, void* vqe)
{
	static_cast<QMenu*>(ptr)->enterEvent(static_cast<QEvent*>(vqe));
}

void QMenu_EnterEventDefault(void* ptr, void* vqe)
{
	static_cast<QMenu*>(ptr)->QMenu::enterEvent(static_cast<QEvent*>(vqe));
}

char QMenu_Event(void* ptr, void* e)
{
	return static_cast<QMenu*>(ptr)->event(static_cast<QEvent*>(e));
}

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));
}

char QMenu_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QMenu*>(ptr)->focusNextPrevChild(next != 0);
}

char QMenu_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QMenu*>(ptr)->QMenu::focusNextPrevChild(next != 0);
}

void QMenu_HideEvent(void* ptr, void* vqh)
{
	static_cast<QMenu*>(ptr)->hideEvent(static_cast<QHideEvent*>(vqh));
}

void QMenu_HideEventDefault(void* ptr, void* vqh)
{
	static_cast<QMenu*>(ptr)->QMenu::hideEvent(static_cast<QHideEvent*>(vqh));
}

void QMenu_HideTearOffMenu(void* ptr)
{
	static_cast<QMenu*>(ptr)->hideTearOffMenu();
}

void QMenu_ConnectHovered(void* ptr)
{
	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));
}

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_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_InsertSection2(void* ptr, void* before, void* icon, char* text)
{
	return static_cast<QMenu*>(ptr)->insertSection(static_cast<QAction*>(before), *static_cast<QIcon*>(icon), QString(text));
}

void* QMenu_InsertSection(void* ptr, void* before, char* text)
{
	return static_cast<QMenu*>(ptr)->insertSection(static_cast<QAction*>(before), QString(text));
}

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_IsTearOffMenuVisible(void* ptr)
{
	return static_cast<QMenu*>(ptr)->isTearOffMenuVisible();
}

void QMenu_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QMenu_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->QMenu::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QMenu_LeaveEvent(void* ptr, void* vqe)
{
	static_cast<QMenu*>(ptr)->leaveEvent(static_cast<QEvent*>(vqe));
}

void QMenu_LeaveEventDefault(void* ptr, void* vqe)
{
	static_cast<QMenu*>(ptr)->QMenu::leaveEvent(static_cast<QEvent*>(vqe));
}

void* QMenu_MenuAction(void* ptr)
{
	return static_cast<QMenu*>(ptr)->menuAction();
}

void QMenu_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QMenu_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->QMenu::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QMenu_MousePressEvent(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QMenu_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->QMenu::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QMenu_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QMenu_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->QMenu::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QMenu_PaintEvent(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->paintEvent(static_cast<QPaintEvent*>(e));
}

void QMenu_PaintEventDefault(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->QMenu::paintEvent(static_cast<QPaintEvent*>(e));
}

void QMenu_Popup(void* ptr, void* p, void* atAction)
{
	static_cast<QMenu*>(ptr)->popup(*static_cast<QPoint*>(p), static_cast<QAction*>(atAction));
}

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_ShowTearOffMenu2(void* ptr)
{
	static_cast<QMenu*>(ptr)->showTearOffMenu();
}

void QMenu_ShowTearOffMenu(void* ptr, void* pos)
{
	static_cast<QMenu*>(ptr)->showTearOffMenu(*static_cast<QPoint*>(pos));
}

void* QMenu_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMenu*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMenu_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMenu*>(ptr)->QMenu::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMenu_TimerEvent(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->timerEvent(static_cast<QTimerEvent*>(e));
}

void QMenu_ConnectTriggered(void* ptr)
{
	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));
}

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_WheelEvent(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QMenu_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QMenu*>(ptr)->QMenu::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QMenu_DestroyQMenu(void* ptr)
{
	static_cast<QMenu*>(ptr)->~QMenu();
}

void QMenu_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMenu_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMenu_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMenu_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMenu_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMenu_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMenu_DropEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QMenu_DropEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::dropEvent(static_cast<QDropEvent*>(event));
}

void QMenu_FocusInEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QMenu_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QMenu_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QMenu_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void* QMenu_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMenu*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMenu_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMenu*>(ptr)->QMenu::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMenu_MoveEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QMenu_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::moveEvent(static_cast<QMoveEvent*>(event));
}

void QMenu_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QMenu_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QMenu*>(ptr)->QMenu::setEnabled(vbo != 0);
}

void QMenu_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QMenu_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QMenu*>(ptr)->QMenu::setStyleSheet(QString(styleSheet));
}

void QMenu_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QMenu_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QMenu*>(ptr)->QMenu::setVisible(visible != 0);
}

void QMenu_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QMenu_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QMenu*>(ptr)->QMenu::setWindowModified(vbo != 0);
}

void QMenu_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QMenu_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QMenu*>(ptr)->QMenu::setWindowTitle(QString(vqs));
}

void QMenu_ShowEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QMenu_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::showEvent(static_cast<QShowEvent*>(event));
}

char QMenu_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QMenu_CloseDefault(void* ptr)
{
	return static_cast<QMenu*>(ptr)->QMenu::close();
}

void QMenu_CloseEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QMenu_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::closeEvent(static_cast<QCloseEvent*>(event));
}

void QMenu_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QMenu_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QMenu_HasHeightForWidth(void* ptr)
{
	return static_cast<QMenu*>(ptr)->hasHeightForWidth();
}

char QMenu_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QMenu*>(ptr)->QMenu::hasHeightForWidth();
}

int QMenu_HeightForWidth(void* ptr, int w)
{
	return static_cast<QMenu*>(ptr)->heightForWidth(w);
}

int QMenu_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QMenu*>(ptr)->QMenu::heightForWidth(w);
}

void QMenu_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "hide");
}

void QMenu_HideDefault(void* ptr)
{
	static_cast<QMenu*>(ptr)->QMenu::hide();
}

void QMenu_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QMenu_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QMenu_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QMenu*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QMenu_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QMenu*>(ptr)->QMenu::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QMenu_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMenu_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMenu_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "lower");
}

void QMenu_LowerDefault(void* ptr)
{
	static_cast<QMenu*>(ptr)->QMenu::lower();
}

void QMenu_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QMenu_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QMenu_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMenu*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QMenu_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMenu*>(ptr)->QMenu::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QMenu_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "raise");
}

void QMenu_RaiseDefault(void* ptr)
{
	static_cast<QMenu*>(ptr)->QMenu::raise();
}

void QMenu_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "repaint");
}

void QMenu_RepaintDefault(void* ptr)
{
	static_cast<QMenu*>(ptr)->QMenu::repaint();
}

void QMenu_ResizeEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QMenu_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QMenu_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QMenu_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QMenu*>(ptr)->QMenu::setDisabled(disable != 0);
}

void QMenu_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "setFocus");
}

void QMenu_SetFocus2Default(void* ptr)
{
	static_cast<QMenu*>(ptr)->QMenu::setFocus();
}

void QMenu_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QMenu_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QMenu*>(ptr)->QMenu::setHidden(hidden != 0);
}

void QMenu_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "show");
}

void QMenu_ShowDefault(void* ptr)
{
	static_cast<QMenu*>(ptr)->QMenu::show();
}

void QMenu_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "showFullScreen");
}

void QMenu_ShowFullScreenDefault(void* ptr)
{
	static_cast<QMenu*>(ptr)->QMenu::showFullScreen();
}

void QMenu_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "showMaximized");
}

void QMenu_ShowMaximizedDefault(void* ptr)
{
	static_cast<QMenu*>(ptr)->QMenu::showMaximized();
}

void QMenu_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "showMinimized");
}

void QMenu_ShowMinimizedDefault(void* ptr)
{
	static_cast<QMenu*>(ptr)->QMenu::showMinimized();
}

void QMenu_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "showNormal");
}

void QMenu_ShowNormalDefault(void* ptr)
{
	static_cast<QMenu*>(ptr)->QMenu::showNormal();
}

void QMenu_TabletEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMenu_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMenu_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "update");
}

void QMenu_UpdateDefault(void* ptr)
{
	static_cast<QMenu*>(ptr)->QMenu::update();
}

void QMenu_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "updateMicroFocus");
}

void QMenu_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QMenu*>(ptr)->QMenu::updateMicroFocus();
}

void QMenu_ChildEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QMenu_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::childEvent(static_cast<QChildEvent*>(event));
}

void QMenu_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QMenu*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMenu_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMenu*>(ptr)->QMenu::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMenu_CustomEvent(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QMenu_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QMenu*>(ptr)->QMenu::customEvent(static_cast<QEvent*>(event));
}

void QMenu_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "deleteLater");
}

void QMenu_DeleteLaterDefault(void* ptr)
{
	static_cast<QMenu*>(ptr)->QMenu::deleteLater();
}

void QMenu_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QMenu*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMenu_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMenu*>(ptr)->QMenu::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QMenu_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QMenu*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QMenu_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QMenu*>(ptr)->QMenu::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QMenu_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMenu*>(ptr)->metaObject());
}

void* QMenu_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMenu*>(ptr)->QMenu::metaObject());
}

class MyQMenuBar: public QMenuBar
{
public:
	MyQMenuBar(QWidget *parent) : QMenuBar(parent) {};
	void actionEvent(QActionEvent * e) { callbackQMenuBar_ActionEvent(this, e); };
	void changeEvent(QEvent * e) { callbackQMenuBar_ChangeEvent(this, e); };
	void focusInEvent(QFocusEvent * vqf) { callbackQMenuBar_FocusInEvent(this, vqf); };
	void focusOutEvent(QFocusEvent * vqf) { callbackQMenuBar_FocusOutEvent(this, vqf); };
	int heightForWidth(int vin) const { return callbackQMenuBar_HeightForWidth(const_cast<MyQMenuBar*>(this), vin); };
	void Signal_Hovered(QAction * action) { callbackQMenuBar_Hovered(this, action); };
	void keyPressEvent(QKeyEvent * e) { callbackQMenuBar_KeyPressEvent(this, e); };
	void leaveEvent(QEvent * vqe) { callbackQMenuBar_LeaveEvent(this, vqe); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMenuBar_MinimumSizeHint(const_cast<MyQMenuBar*>(this))); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQMenuBar_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQMenuBar_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQMenuBar_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQMenuBar_PaintEvent(this, e); };
	void resizeEvent(QResizeEvent * vqr) { callbackQMenuBar_ResizeEvent(this, vqr); };
	void setVisible(bool visible) { callbackQMenuBar_SetVisible(this, visible); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQMenuBar_SizeHint(const_cast<MyQMenuBar*>(this))); };
	void Signal_Triggered(QAction * action) { callbackQMenuBar_Triggered(this, action); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQMenuBar_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMenuBar_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQMenuBar_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQMenuBar_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQMenuBar_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQMenuBar_HideEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQMenuBar_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQMenuBar_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQMenuBar_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setWindowModified(bool vbo) { callbackQMenuBar_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQMenuBar_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQMenuBar_ShowEvent(this, event); };
	bool close() { return callbackQMenuBar_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQMenuBar_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQMenuBar_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQMenuBar_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQMenuBar_HasHeightForWidth(const_cast<MyQMenuBar*>(this)) != 0; };
	void hide() { callbackQMenuBar_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQMenuBar_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMenuBar_InputMethodQuery(const_cast<MyQMenuBar*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQMenuBar_KeyReleaseEvent(this, event); };
	void lower() { callbackQMenuBar_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQMenuBar_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMenuBar_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQMenuBar_Raise(this); };
	void repaint() { callbackQMenuBar_Repaint(this); };
	void setDisabled(bool disable) { callbackQMenuBar_SetDisabled(this, disable); };
	void setFocus() { callbackQMenuBar_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQMenuBar_SetHidden(this, hidden); };
	void show() { callbackQMenuBar_Show(this); };
	void showFullScreen() { callbackQMenuBar_ShowFullScreen(this); };
	void showMaximized() { callbackQMenuBar_ShowMaximized(this); };
	void showMinimized() { callbackQMenuBar_ShowMinimized(this); };
	void showNormal() { callbackQMenuBar_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQMenuBar_TabletEvent(this, event); };
	void update() { callbackQMenuBar_Update(this); };
	void updateMicroFocus() { callbackQMenuBar_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQMenuBar_WheelEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQMenuBar_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMenuBar_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMenuBar_CustomEvent(this, event); };
	void deleteLater() { callbackQMenuBar_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMenuBar_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMenuBar_MetaObject(const_cast<MyQMenuBar*>(this))); };
};

char QMenuBar_IsDefaultUp(void* ptr)
{
	return static_cast<QMenuBar*>(ptr)->isDefaultUp();
}

char QMenuBar_IsNativeMenuBar(void* ptr)
{
	return static_cast<QMenuBar*>(ptr)->isNativeMenuBar();
}

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_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_ActionEvent(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->actionEvent(static_cast<QActionEvent*>(e));
}

void QMenuBar_ActionEventDefault(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::actionEvent(static_cast<QActionEvent*>(e));
}

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, char* text)
{
	return static_cast<QMenuBar*>(ptr)->addAction(QString(text));
}

void* QMenuBar_AddAction2(void* ptr, char* text, void* receiver, char* member)
{
	return static_cast<QMenuBar*>(ptr)->addAction(QString(text), 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_AddMenu3(void* ptr, void* icon, char* title)
{
	return static_cast<QMenuBar*>(ptr)->addMenu(*static_cast<QIcon*>(icon), QString(title));
}

void* QMenuBar_AddMenu2(void* ptr, char* title)
{
	return static_cast<QMenuBar*>(ptr)->addMenu(QString(title));
}

void* QMenuBar_AddSeparator(void* ptr)
{
	return static_cast<QMenuBar*>(ptr)->addSeparator();
}

void QMenuBar_ChangeEvent(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QMenuBar_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::changeEvent(static_cast<QEvent*>(e));
}

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_DefaultAction(void* ptr)
{
#ifdef Q_OS_WINCE
	return static_cast<QMenuBar*>(ptr)->defaultAction();
#else
	return NULL;
#endif
}

char QMenuBar_Event(void* ptr, void* e)
{
	return static_cast<QMenuBar*>(ptr)->event(static_cast<QEvent*>(e));
}

char QMenuBar_EventFilter(void* ptr, void* object, void* event)
{
	return static_cast<QMenuBar*>(ptr)->eventFilter(static_cast<QObject*>(object), static_cast<QEvent*>(event));
}

void QMenuBar_FocusInEvent(void* ptr, void* vqf)
{
	static_cast<QMenuBar*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(vqf));
}

void QMenuBar_FocusInEventDefault(void* ptr, void* vqf)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::focusInEvent(static_cast<QFocusEvent*>(vqf));
}

void QMenuBar_FocusOutEvent(void* ptr, void* vqf)
{
	static_cast<QMenuBar*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(vqf));
}

void QMenuBar_FocusOutEventDefault(void* ptr, void* vqf)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::focusOutEvent(static_cast<QFocusEvent*>(vqf));
}

int QMenuBar_HeightForWidth(void* ptr, int vin)
{
	return static_cast<QMenuBar*>(ptr)->heightForWidth(vin);
}

int QMenuBar_HeightForWidthDefault(void* ptr, int vin)
{
	return static_cast<QMenuBar*>(ptr)->QMenuBar::heightForWidth(vin);
}

void QMenuBar_ConnectHovered(void* ptr)
{
	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));
}

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));
}

void QMenuBar_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QMenuBar_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QMenuBar_LeaveEvent(void* ptr, void* vqe)
{
	static_cast<QMenuBar*>(ptr)->leaveEvent(static_cast<QEvent*>(vqe));
}

void QMenuBar_LeaveEventDefault(void* ptr, void* vqe)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::leaveEvent(static_cast<QEvent*>(vqe));
}

void* QMenuBar_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMenuBar*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMenuBar_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMenuBar*>(ptr)->QMenuBar::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMenuBar_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QMenuBar_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QMenuBar_MousePressEvent(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QMenuBar_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QMenuBar_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QMenuBar_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QMenuBar_PaintEvent(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->paintEvent(static_cast<QPaintEvent*>(e));
}

void QMenuBar_PaintEventDefault(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::paintEvent(static_cast<QPaintEvent*>(e));
}

void QMenuBar_ResizeEvent(void* ptr, void* vqr)
{
	static_cast<QMenuBar*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QMenuBar_ResizeEventDefault(void* ptr, void* vqr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QMenuBar_SetActiveAction(void* ptr, void* act)
{
	static_cast<QMenuBar*>(ptr)->setActiveAction(static_cast<QAction*>(act));
}

void QMenuBar_SetDefaultAction(void* ptr, void* act)
{
#ifdef Q_OS_WINCE
	static_cast<QMenuBar*>(ptr)->setDefaultAction(static_cast<QAction*>(act));
#endif
}

void QMenuBar_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QMenuBar_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::setVisible(visible != 0);
}

void* QMenuBar_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMenuBar*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMenuBar_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMenuBar*>(ptr)->QMenuBar::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMenuBar_TimerEvent(void* ptr, void* e)
{
	static_cast<QMenuBar*>(ptr)->timerEvent(static_cast<QTimerEvent*>(e));
}

void QMenuBar_ConnectTriggered(void* ptr)
{
	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));
}

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_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMenuBar_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMenuBar_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMenuBar_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMenuBar_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMenuBar_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMenuBar_DropEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QMenuBar_DropEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::dropEvent(static_cast<QDropEvent*>(event));
}

void QMenuBar_EnterEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QMenuBar_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::enterEvent(static_cast<QEvent*>(event));
}

void QMenuBar_HideEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QMenuBar_HideEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::hideEvent(static_cast<QHideEvent*>(event));
}

void QMenuBar_MoveEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QMenuBar_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::moveEvent(static_cast<QMoveEvent*>(event));
}

void QMenuBar_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QMenuBar_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::setEnabled(vbo != 0);
}

void QMenuBar_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QMenuBar_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::setStyleSheet(QString(styleSheet));
}

void QMenuBar_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QMenuBar_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::setWindowModified(vbo != 0);
}

void QMenuBar_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QMenuBar_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::setWindowTitle(QString(vqs));
}

void QMenuBar_ShowEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QMenuBar_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::showEvent(static_cast<QShowEvent*>(event));
}

char QMenuBar_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QMenuBar_CloseDefault(void* ptr)
{
	return static_cast<QMenuBar*>(ptr)->QMenuBar::close();
}

void QMenuBar_CloseEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QMenuBar_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::closeEvent(static_cast<QCloseEvent*>(event));
}

void QMenuBar_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QMenuBar_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QMenuBar_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QMenuBar*>(ptr)->focusNextPrevChild(next != 0);
}

char QMenuBar_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QMenuBar*>(ptr)->QMenuBar::focusNextPrevChild(next != 0);
}

char QMenuBar_HasHeightForWidth(void* ptr)
{
	return static_cast<QMenuBar*>(ptr)->hasHeightForWidth();
}

char QMenuBar_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QMenuBar*>(ptr)->QMenuBar::hasHeightForWidth();
}

void QMenuBar_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "hide");
}

void QMenuBar_HideDefault(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::hide();
}

void QMenuBar_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QMenuBar_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QMenuBar_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QMenuBar*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QMenuBar_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QMenuBar*>(ptr)->QMenuBar::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QMenuBar_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMenuBar_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMenuBar_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "lower");
}

void QMenuBar_LowerDefault(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::lower();
}

void QMenuBar_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QMenuBar_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QMenuBar_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMenuBar*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QMenuBar_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMenuBar*>(ptr)->QMenuBar::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QMenuBar_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "raise");
}

void QMenuBar_RaiseDefault(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::raise();
}

void QMenuBar_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "repaint");
}

void QMenuBar_RepaintDefault(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::repaint();
}

void QMenuBar_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QMenuBar_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::setDisabled(disable != 0);
}

void QMenuBar_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "setFocus");
}

void QMenuBar_SetFocus2Default(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::setFocus();
}

void QMenuBar_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QMenuBar_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::setHidden(hidden != 0);
}

void QMenuBar_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "show");
}

void QMenuBar_ShowDefault(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::show();
}

void QMenuBar_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "showFullScreen");
}

void QMenuBar_ShowFullScreenDefault(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::showFullScreen();
}

void QMenuBar_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "showMaximized");
}

void QMenuBar_ShowMaximizedDefault(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::showMaximized();
}

void QMenuBar_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "showMinimized");
}

void QMenuBar_ShowMinimizedDefault(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::showMinimized();
}

void QMenuBar_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "showNormal");
}

void QMenuBar_ShowNormalDefault(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::showNormal();
}

void QMenuBar_TabletEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMenuBar_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMenuBar_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "update");
}

void QMenuBar_UpdateDefault(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::update();
}

void QMenuBar_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "updateMicroFocus");
}

void QMenuBar_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::updateMicroFocus();
}

void QMenuBar_WheelEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QMenuBar_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QMenuBar_ChildEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QMenuBar_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::childEvent(static_cast<QChildEvent*>(event));
}

void QMenuBar_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QMenuBar*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMenuBar_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMenuBar_CustomEvent(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QMenuBar_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::customEvent(static_cast<QEvent*>(event));
}

void QMenuBar_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "deleteLater");
}

void QMenuBar_DeleteLaterDefault(void* ptr)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::deleteLater();
}

void QMenuBar_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QMenuBar*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMenuBar_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMenuBar*>(ptr)->QMenuBar::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void* QMenuBar_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMenuBar*>(ptr)->metaObject());
}

void* QMenuBar_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMenuBar*>(ptr)->QMenuBar::metaObject());
}

int QMessageBox_ButtonMask_Type()
{
	return QMessageBox::ButtonMask;
}

class MyQMessageBox: public QMessageBox
{
public:
	MyQMessageBox(Icon icon, const QString &title, const QString &text, StandardButtons buttons, QWidget *parent, Qt::WindowFlags f) : QMessageBox(icon, title, text, buttons, parent, f) {};
	MyQMessageBox(QWidget *parent) : QMessageBox(parent) {};
	void Signal_ButtonClicked(QAbstractButton * button) { callbackQMessageBox_ButtonClicked(this, button); };
	void changeEvent(QEvent * ev) { callbackQMessageBox_ChangeEvent(this, ev); };
	void closeEvent(QCloseEvent * e) { callbackQMessageBox_CloseEvent(this, e); };
	int exec() { return callbackQMessageBox_Exec(this); };
	void keyPressEvent(QKeyEvent * e) { callbackQMessageBox_KeyPressEvent(this, e); };
	void resizeEvent(QResizeEvent * event) { callbackQMessageBox_ResizeEvent(this, event); };
	void setVisible(bool visible) { callbackQMessageBox_SetVisible(this, visible); };
	void showEvent(QShowEvent * e) { callbackQMessageBox_ShowEvent(this, e); };
	void accept() { callbackQMessageBox_Accept(this); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQMessageBox_ContextMenuEvent(this, e); };
	void done(int r) { callbackQMessageBox_Done(this, r); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMessageBox_MinimumSizeHint(const_cast<MyQMessageBox*>(this))); };
	void reject() { callbackQMessageBox_Reject(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQMessageBox_SizeHint(const_cast<MyQMessageBox*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQMessageBox_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQMessageBox_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMessageBox_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQMessageBox_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQMessageBox_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQMessageBox_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQMessageBox_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQMessageBox_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQMessageBox_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQMessageBox_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQMessageBox_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQMessageBox_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQMessageBox_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQMessageBox_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setWindowModified(bool vbo) { callbackQMessageBox_SetWindowModified(this, vbo); };
	bool close() { return callbackQMessageBox_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQMessageBox_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQMessageBox_HasHeightForWidth(const_cast<MyQMessageBox*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQMessageBox_HeightForWidth(const_cast<MyQMessageBox*>(this), w); };
	void hide() { callbackQMessageBox_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQMessageBox_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMessageBox_InputMethodQuery(const_cast<MyQMessageBox*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQMessageBox_KeyReleaseEvent(this, event); };
	void lower() { callbackQMessageBox_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQMessageBox_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQMessageBox_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQMessageBox_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQMessageBox_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMessageBox_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQMessageBox_Raise(this); };
	void repaint() { callbackQMessageBox_Repaint(this); };
	void setDisabled(bool disable) { callbackQMessageBox_SetDisabled(this, disable); };
	void setFocus() { callbackQMessageBox_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQMessageBox_SetHidden(this, hidden); };
	void show() { callbackQMessageBox_Show(this); };
	void showFullScreen() { callbackQMessageBox_ShowFullScreen(this); };
	void showMaximized() { callbackQMessageBox_ShowMaximized(this); };
	void showMinimized() { callbackQMessageBox_ShowMinimized(this); };
	void showNormal() { callbackQMessageBox_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQMessageBox_TabletEvent(this, event); };
	void update() { callbackQMessageBox_Update(this); };
	void updateMicroFocus() { callbackQMessageBox_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQMessageBox_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQMessageBox_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQMessageBox_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMessageBox_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMessageBox_CustomEvent(this, event); };
	void deleteLater() { callbackQMessageBox_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMessageBox_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMessageBox_MetaObject(const_cast<MyQMessageBox*>(this))); };
};

char* QMessageBox_DetailedText(void* ptr)
{
	return const_cast<char*>(static_cast<QMessageBox*>(ptr)->detailedText().toUtf8().prepend("WHITESPACE").constData()+10);
}

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());
}

char* QMessageBox_InformativeText(void* ptr)
{
	return const_cast<char*>(static_cast<QMessageBox*>(ptr)->informativeText().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QMessageBox_SetDetailedText(void* ptr, char* text)
{
	static_cast<QMessageBox*>(ptr)->setDetailedText(QString(text));
}

void QMessageBox_SetIcon(void* ptr, long long vic)
{
	static_cast<QMessageBox*>(ptr)->setIcon(static_cast<QMessageBox::Icon>(vic));
}

void QMessageBox_SetIconPixmap(void* ptr, void* pixmap)
{
	static_cast<QMessageBox*>(ptr)->setIconPixmap(*static_cast<QPixmap*>(pixmap));
}

void QMessageBox_SetInformativeText(void* ptr, char* text)
{
	static_cast<QMessageBox*>(ptr)->setInformativeText(QString(text));
}

void QMessageBox_SetStandardButtons(void* ptr, long long buttons)
{
	static_cast<QMessageBox*>(ptr)->setStandardButtons(static_cast<QMessageBox::StandardButton>(buttons));
}

void QMessageBox_SetText(void* ptr, char* text)
{
	static_cast<QMessageBox*>(ptr)->setText(QString(text));
}

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));
}

long long QMessageBox_StandardButtons(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->standardButtons();
}

char* QMessageBox_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QMessageBox*>(ptr)->text().toUtf8().prepend("WHITESPACE").constData()+10);
}

long long QMessageBox_TextFormat(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->textFormat();
}

long long QMessageBox_TextInteractionFlags(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->textInteractionFlags();
}

void* QMessageBox_NewQMessageBox2(long long icon, char* title, char* text, long long buttons, void* parent, long long f)
{
	return new MyQMessageBox(static_cast<QMessageBox::Icon>(icon), QString(title), QString(text), static_cast<QMessageBox::StandardButton>(buttons), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
}

void* QMessageBox_NewQMessageBox(void* parent)
{
	return new MyQMessageBox(static_cast<QWidget*>(parent));
}

void QMessageBox_QMessageBox_About(void* parent, char* title, char* text)
{
	QMessageBox::about(static_cast<QWidget*>(parent), QString(title), QString(text));
}

void QMessageBox_QMessageBox_AboutQt(void* parent, char* title)
{
	QMessageBox::aboutQt(static_cast<QWidget*>(parent), QString(title));
}

void* QMessageBox_AddButton3(void* ptr, long long button)
{
	return static_cast<QMessageBox*>(ptr)->addButton(static_cast<QMessageBox::StandardButton>(button));
}

void* QMessageBox_AddButton2(void* ptr, char* text, long long role)
{
	return static_cast<QMessageBox*>(ptr)->addButton(QString(text), static_cast<QMessageBox::ButtonRole>(role));
}

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_Button(void* ptr, long long which)
{
	return static_cast<QMessageBox*>(ptr)->button(static_cast<QMessageBox::StandardButton>(which));
}

void QMessageBox_ConnectButtonClicked(void* ptr)
{
	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));
}

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));
}

void QMessageBox_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QMessageBox*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QMessageBox_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::changeEvent(static_cast<QEvent*>(ev));
}

void* QMessageBox_CheckBox(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->checkBox();
}

void* QMessageBox_ClickedButton(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->clickedButton();
}

void QMessageBox_CloseEvent(void* ptr, void* e)
{
	static_cast<QMessageBox*>(ptr)->closeEvent(static_cast<QCloseEvent*>(e));
}

void QMessageBox_CloseEventDefault(void* ptr, void* e)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::closeEvent(static_cast<QCloseEvent*>(e));
}

long long QMessageBox_QMessageBox_Critical(void* parent, char* title, char* text, long long buttons, long long defaultButton)
{
	return QMessageBox::critical(static_cast<QWidget*>(parent), QString(title), QString(text), static_cast<QMessageBox::StandardButton>(buttons), static_cast<QMessageBox::StandardButton>(defaultButton));
}

void* QMessageBox_DefaultButton(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->defaultButton();
}

void* QMessageBox_EscapeButton(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->escapeButton();
}

char QMessageBox_Event(void* ptr, void* e)
{
	return static_cast<QMessageBox*>(ptr)->event(static_cast<QEvent*>(e));
}

int QMessageBox_Exec(void* ptr)
{
	int returnArg;
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "exec", Q_RETURN_ARG(int, returnArg));
	return returnArg;
}

int QMessageBox_ExecDefault(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->QMessageBox::exec();
}

long long QMessageBox_QMessageBox_Information(void* parent, char* title, char* text, long long buttons, long long defaultButton)
{
	return QMessageBox::information(static_cast<QWidget*>(parent), QString(title), QString(text), static_cast<QMessageBox::StandardButton>(buttons), static_cast<QMessageBox::StandardButton>(defaultButton));
}

void QMessageBox_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QMessageBox*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QMessageBox_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QMessageBox_Open(void* ptr, void* receiver, char* member)
{
	static_cast<QMessageBox*>(ptr)->open(static_cast<QObject*>(receiver), const_cast<const char*>(member));
}

long long QMessageBox_QMessageBox_Question(void* parent, char* title, char* text, long long buttons, long long defaultButton)
{
	return QMessageBox::question(static_cast<QWidget*>(parent), QString(title), QString(text), 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_ResizeEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QMessageBox_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::resizeEvent(static_cast<QResizeEvent*>(event));
}

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_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_SetVisible(void* ptr, char visible)
{
	static_cast<QMessageBox*>(ptr)->setVisible(visible != 0);
}

void QMessageBox_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::setVisible(visible != 0);
}

void QMessageBox_SetWindowModality(void* ptr, long long windowModality)
{
	static_cast<QMessageBox*>(ptr)->setWindowModality(static_cast<Qt::WindowModality>(windowModality));
}

void QMessageBox_SetWindowTitle(void* ptr, char* title)
{
	static_cast<QMessageBox*>(ptr)->setWindowTitle(QString(title));
}

void QMessageBox_ShowEvent(void* ptr, void* e)
{
	static_cast<QMessageBox*>(ptr)->showEvent(static_cast<QShowEvent*>(e));
}

void QMessageBox_ShowEventDefault(void* ptr, void* e)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::showEvent(static_cast<QShowEvent*>(e));
}

long long QMessageBox_StandardButton(void* ptr, void* button)
{
	return static_cast<QMessageBox*>(ptr)->standardButton(static_cast<QAbstractButton*>(button));
}

long long QMessageBox_QMessageBox_Warning(void* parent, char* title, char* text, long long buttons, long long defaultButton)
{
	return QMessageBox::warning(static_cast<QWidget*>(parent), QString(title), QString(text), static_cast<QMessageBox::StandardButton>(buttons), static_cast<QMessageBox::StandardButton>(defaultButton));
}

void QMessageBox_DestroyQMessageBox(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->~QMessageBox();
}

void QMessageBox_Accept(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "accept");
}

void QMessageBox_AcceptDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::accept();
}

void QMessageBox_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QMessageBox*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QMessageBox_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QMessageBox_Done(void* ptr, int r)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "done", Q_ARG(int, r));
}

void QMessageBox_DoneDefault(void* ptr, int r)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::done(r);
}

void* QMessageBox_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMessageBox*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMessageBox_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMessageBox*>(ptr)->QMessageBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMessageBox_Reject(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "reject");
}

void QMessageBox_RejectDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::reject();
}

void* QMessageBox_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMessageBox*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QMessageBox_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMessageBox*>(ptr)->QMessageBox::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QMessageBox_ActionEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QMessageBox_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::actionEvent(static_cast<QActionEvent*>(event));
}

void QMessageBox_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMessageBox_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QMessageBox_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMessageBox_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QMessageBox_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMessageBox_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QMessageBox_DropEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QMessageBox_DropEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::dropEvent(static_cast<QDropEvent*>(event));
}

void QMessageBox_EnterEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QMessageBox_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::enterEvent(static_cast<QEvent*>(event));
}

void QMessageBox_FocusInEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QMessageBox_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QMessageBox_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QMessageBox_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QMessageBox_HideEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QMessageBox_HideEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::hideEvent(static_cast<QHideEvent*>(event));
}

void QMessageBox_LeaveEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QMessageBox_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::leaveEvent(static_cast<QEvent*>(event));
}

void QMessageBox_MoveEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QMessageBox_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::moveEvent(static_cast<QMoveEvent*>(event));
}

void QMessageBox_PaintEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QMessageBox_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::paintEvent(static_cast<QPaintEvent*>(event));
}

void QMessageBox_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QMessageBox_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::setEnabled(vbo != 0);
}

void QMessageBox_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QMessageBox_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::setStyleSheet(QString(styleSheet));
}

void QMessageBox_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QMessageBox_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::setWindowModified(vbo != 0);
}

char QMessageBox_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QMessageBox_CloseDefault(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->QMessageBox::close();
}

char QMessageBox_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QMessageBox*>(ptr)->focusNextPrevChild(next != 0);
}

char QMessageBox_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QMessageBox*>(ptr)->QMessageBox::focusNextPrevChild(next != 0);
}

char QMessageBox_HasHeightForWidth(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->hasHeightForWidth();
}

char QMessageBox_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QMessageBox*>(ptr)->QMessageBox::hasHeightForWidth();
}

int QMessageBox_HeightForWidth(void* ptr, int w)
{
	return static_cast<QMessageBox*>(ptr)->heightForWidth(w);
}

int QMessageBox_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QMessageBox*>(ptr)->QMessageBox::heightForWidth(w);
}

void QMessageBox_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "hide");
}

void QMessageBox_HideDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::hide();
}

void QMessageBox_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QMessageBox_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QMessageBox_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QMessageBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QMessageBox_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QMessageBox*>(ptr)->QMessageBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QMessageBox_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMessageBox_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QMessageBox_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "lower");
}

void QMessageBox_LowerDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::lower();
}

void QMessageBox_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QMessageBox_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QMessageBox_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QMessageBox_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QMessageBox_MousePressEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QMessageBox_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QMessageBox_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QMessageBox_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QMessageBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMessageBox*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QMessageBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QMessageBox*>(ptr)->QMessageBox::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QMessageBox_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "raise");
}

void QMessageBox_RaiseDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::raise();
}

void QMessageBox_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "repaint");
}

void QMessageBox_RepaintDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::repaint();
}

void QMessageBox_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QMessageBox_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::setDisabled(disable != 0);
}

void QMessageBox_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "setFocus");
}

void QMessageBox_SetFocus2Default(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::setFocus();
}

void QMessageBox_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QMessageBox_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::setHidden(hidden != 0);
}

void QMessageBox_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "show");
}

void QMessageBox_ShowDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::show();
}

void QMessageBox_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "showFullScreen");
}

void QMessageBox_ShowFullScreenDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::showFullScreen();
}

void QMessageBox_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "showMaximized");
}

void QMessageBox_ShowMaximizedDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::showMaximized();
}

void QMessageBox_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "showMinimized");
}

void QMessageBox_ShowMinimizedDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::showMinimized();
}

void QMessageBox_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "showNormal");
}

void QMessageBox_ShowNormalDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::showNormal();
}

void QMessageBox_TabletEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMessageBox_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QMessageBox_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "update");
}

void QMessageBox_UpdateDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::update();
}

void QMessageBox_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "updateMicroFocus");
}

void QMessageBox_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::updateMicroFocus();
}

void QMessageBox_WheelEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QMessageBox_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QMessageBox_TimerEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QMessageBox_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::timerEvent(static_cast<QTimerEvent*>(event));
}

void QMessageBox_ChildEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QMessageBox_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::childEvent(static_cast<QChildEvent*>(event));
}

void QMessageBox_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QMessageBox*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMessageBox_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMessageBox_CustomEvent(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QMessageBox_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::customEvent(static_cast<QEvent*>(event));
}

void QMessageBox_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "deleteLater");
}

void QMessageBox_DeleteLaterDefault(void* ptr)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::deleteLater();
}

void QMessageBox_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QMessageBox*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMessageBox_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMessageBox*>(ptr)->QMessageBox::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void* QMessageBox_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMessageBox*>(ptr)->metaObject());
}

void* QMessageBox_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMessageBox*>(ptr)->QMessageBox::metaObject());
}

void* QMouseEventTransition_NewQMouseEventTransition2(void* object, long long ty, long long button, void* sourceState)
{
	return new QMouseEventTransition(static_cast<QObject*>(object), static_cast<QEvent::Type>(ty), static_cast<Qt::MouseButton>(button), static_cast<QState*>(sourceState));
}

void* QMouseEventTransition_NewQMouseEventTransition(void* sourceState)
{
	return new QMouseEventTransition(static_cast<QState*>(sourceState));
}

long long QMouseEventTransition_Button(void* ptr)
{
	return static_cast<QMouseEventTransition*>(ptr)->button();
}

char QMouseEventTransition_EventTest(void* ptr, void* event)
{
	return static_cast<QMouseEventTransition*>(ptr)->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_OnTransition(void* ptr, void* event)
{
	static_cast<QMouseEventTransition*>(ptr)->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();
}

char QMouseEventTransition_Event(void* ptr, void* e)
{
	return static_cast<QMouseEventTransition*>(ptr)->event(static_cast<QEvent*>(e));
}

char QMouseEventTransition_EventDefault(void* ptr, void* e)
{
	return static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::event(static_cast<QEvent*>(e));
}

void QMouseEventTransition_TimerEvent(void* ptr, void* event)
{
	static_cast<QMouseEventTransition*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QMouseEventTransition_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::timerEvent(static_cast<QTimerEvent*>(event));
}

void QMouseEventTransition_ChildEvent(void* ptr, void* event)
{
	static_cast<QMouseEventTransition*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QMouseEventTransition_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::childEvent(static_cast<QChildEvent*>(event));
}

void QMouseEventTransition_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QMouseEventTransition*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMouseEventTransition_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMouseEventTransition_CustomEvent(void* ptr, void* event)
{
	static_cast<QMouseEventTransition*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QMouseEventTransition_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::customEvent(static_cast<QEvent*>(event));
}

void QMouseEventTransition_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMouseEventTransition*>(ptr), "deleteLater");
}

void QMouseEventTransition_DeleteLaterDefault(void* ptr)
{
	static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::deleteLater();
}

void QMouseEventTransition_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QMouseEventTransition*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMouseEventTransition_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QMouseEventTransition_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QMouseEventTransition*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QMouseEventTransition_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QMouseEventTransition_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMouseEventTransition*>(ptr)->metaObject());
}

void* QMouseEventTransition_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QMouseEventTransition*>(ptr)->QMouseEventTransition::metaObject());
}

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_TimerEvent(void* ptr, void* event)
{
	static_cast<QPanGesture*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QPanGesture_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QPanGesture*>(ptr)->QPanGesture::timerEvent(static_cast<QTimerEvent*>(event));
}

void QPanGesture_ChildEvent(void* ptr, void* event)
{
	static_cast<QPanGesture*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QPanGesture_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QPanGesture*>(ptr)->QPanGesture::childEvent(static_cast<QChildEvent*>(event));
}

void QPanGesture_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QPanGesture*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPanGesture_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QPanGesture*>(ptr)->QPanGesture::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPanGesture_CustomEvent(void* ptr, void* event)
{
	static_cast<QPanGesture*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QPanGesture_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QPanGesture*>(ptr)->QPanGesture::customEvent(static_cast<QEvent*>(event));
}

void QPanGesture_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPanGesture*>(ptr), "deleteLater");
}

void QPanGesture_DeleteLaterDefault(void* ptr)
{
	static_cast<QPanGesture*>(ptr)->QPanGesture::deleteLater();
}

void QPanGesture_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QPanGesture*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPanGesture_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QPanGesture*>(ptr)->QPanGesture::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QPanGesture_Event(void* ptr, void* e)
{
	return static_cast<QPanGesture*>(ptr)->event(static_cast<QEvent*>(e));
}

char QPanGesture_EventDefault(void* ptr, void* e)
{
	return static_cast<QPanGesture*>(ptr)->QPanGesture::event(static_cast<QEvent*>(e));
}

char QPanGesture_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QPanGesture*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QPanGesture_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QPanGesture*>(ptr)->QPanGesture::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QPanGesture_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QPanGesture*>(ptr)->metaObject());
}

void* QPanGesture_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QPanGesture*>(ptr)->QPanGesture::metaObject());
}

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_TimerEvent(void* ptr, void* event)
{
	static_cast<QPinchGesture*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QPinchGesture_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QPinchGesture*>(ptr)->QPinchGesture::timerEvent(static_cast<QTimerEvent*>(event));
}

void QPinchGesture_ChildEvent(void* ptr, void* event)
{
	static_cast<QPinchGesture*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QPinchGesture_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QPinchGesture*>(ptr)->QPinchGesture::childEvent(static_cast<QChildEvent*>(event));
}

void QPinchGesture_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QPinchGesture*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPinchGesture_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QPinchGesture*>(ptr)->QPinchGesture::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPinchGesture_CustomEvent(void* ptr, void* event)
{
	static_cast<QPinchGesture*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QPinchGesture_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QPinchGesture*>(ptr)->QPinchGesture::customEvent(static_cast<QEvent*>(event));
}

void QPinchGesture_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPinchGesture*>(ptr), "deleteLater");
}

void QPinchGesture_DeleteLaterDefault(void* ptr)
{
	static_cast<QPinchGesture*>(ptr)->QPinchGesture::deleteLater();
}

void QPinchGesture_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QPinchGesture*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPinchGesture_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QPinchGesture*>(ptr)->QPinchGesture::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QPinchGesture_Event(void* ptr, void* e)
{
	return static_cast<QPinchGesture*>(ptr)->event(static_cast<QEvent*>(e));
}

char QPinchGesture_EventDefault(void* ptr, void* e)
{
	return static_cast<QPinchGesture*>(ptr)->QPinchGesture::event(static_cast<QEvent*>(e));
}

char QPinchGesture_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QPinchGesture*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QPinchGesture_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QPinchGesture*>(ptr)->QPinchGesture::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QPinchGesture_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QPinchGesture*>(ptr)->metaObject());
}

void* QPinchGesture_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QPinchGesture*>(ptr)->QPinchGesture::metaObject());
}

int QPlainTextDocumentLayout_CursorWidth(void* ptr)
{
	return static_cast<QPlainTextDocumentLayout*>(ptr)->cursorWidth();
}

void QPlainTextDocumentLayout_SetCursorWidth(void* ptr, int width)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->setCursorWidth(width);
}

void* QPlainTextDocumentLayout_NewQPlainTextDocumentLayout(void* document)
{
	return new QPlainTextDocumentLayout(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_DocumentChanged(void* ptr, int from, int charsRemoved, int charsAdded)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->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_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()); });
}

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_PageCount(void* ptr)
{
	return static_cast<QPlainTextDocumentLayout*>(ptr)->pageCount();
}

void QPlainTextDocumentLayout_RequestUpdate(void* ptr)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->requestUpdate();
}

void QPlainTextDocumentLayout_DestroyQPlainTextDocumentLayout(void* ptr)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->~QPlainTextDocumentLayout();
}

void QPlainTextDocumentLayout_TimerEvent(void* ptr, void* event)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QPlainTextDocumentLayout_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::timerEvent(static_cast<QTimerEvent*>(event));
}

void QPlainTextDocumentLayout_ChildEvent(void* ptr, void* event)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QPlainTextDocumentLayout_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::childEvent(static_cast<QChildEvent*>(event));
}

void QPlainTextDocumentLayout_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPlainTextDocumentLayout_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPlainTextDocumentLayout_CustomEvent(void* ptr, void* event)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QPlainTextDocumentLayout_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::customEvent(static_cast<QEvent*>(event));
}

void QPlainTextDocumentLayout_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextDocumentLayout*>(ptr), "deleteLater");
}

void QPlainTextDocumentLayout_DeleteLaterDefault(void* ptr)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::deleteLater();
}

void QPlainTextDocumentLayout_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPlainTextDocumentLayout_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QPlainTextDocumentLayout_Event(void* ptr, void* e)
{
	return static_cast<QPlainTextDocumentLayout*>(ptr)->event(static_cast<QEvent*>(e));
}

char QPlainTextDocumentLayout_EventDefault(void* ptr, void* e)
{
	return static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::event(static_cast<QEvent*>(e));
}

char QPlainTextDocumentLayout_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QPlainTextDocumentLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QPlainTextDocumentLayout_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QPlainTextDocumentLayout_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QPlainTextDocumentLayout*>(ptr)->metaObject());
}

void* QPlainTextDocumentLayout_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::metaObject());
}

class MyQPlainTextEdit: public QPlainTextEdit
{
public:
	MyQPlainTextEdit(QWidget *parent) : QPlainTextEdit(parent) {};
	MyQPlainTextEdit(const QString &text, QWidget *parent) : QPlainTextEdit(text, parent) {};
	void contextMenuEvent(QContextMenuEvent * event) { callbackQPlainTextEdit_ContextMenuEvent(this, event); };
	void redo() { callbackQPlainTextEdit_Redo(this); };
	void zoomIn(int ran) { callbackQPlainTextEdit_ZoomIn(this, ran); };
	void zoomOut(int ran) { callbackQPlainTextEdit_ZoomOut(this, ran); };
	void appendHtml(const QString & html) { callbackQPlainTextEdit_AppendHtml(this, const_cast<char*>(html.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void appendPlainText(const QString & text) { callbackQPlainTextEdit_AppendPlainText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_BlockCountChanged(int newBlockCount) { callbackQPlainTextEdit_BlockCountChanged(this, newBlockCount); };
	bool canInsertFromMimeData(const QMimeData * source) const { return callbackQPlainTextEdit_CanInsertFromMimeData(const_cast<MyQPlainTextEdit*>(this), const_cast<QMimeData*>(source)) != 0; };
	void centerCursor() { callbackQPlainTextEdit_CenterCursor(this); };
	void changeEvent(QEvent * e) { callbackQPlainTextEdit_ChangeEvent(this, e); };
	void clear() { callbackQPlainTextEdit_Clear(this); };
	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<MyQPlainTextEdit*>(this))); };
	void Signal_CursorPositionChanged() { callbackQPlainTextEdit_CursorPositionChanged(this); };
	void cut() { callbackQPlainTextEdit_Cut(this); };
	void dragEnterEvent(QDragEnterEvent * e) { callbackQPlainTextEdit_DragEnterEvent(this, e); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQPlainTextEdit_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQPlainTextEdit_DragMoveEvent(this, e); };
	void dropEvent(QDropEvent * e) { callbackQPlainTextEdit_DropEvent(this, e); };
	void focusInEvent(QFocusEvent * e) { callbackQPlainTextEdit_FocusInEvent(this, e); };
	bool focusNextPrevChild(bool next) { return callbackQPlainTextEdit_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * e) { callbackQPlainTextEdit_FocusOutEvent(this, e); };
	void inputMethodEvent(QInputMethodEvent * e) { callbackQPlainTextEdit_InputMethodEvent(this, e); };
	QVariant inputMethodQuery(Qt::InputMethodQuery property) const { return *static_cast<QVariant*>(callbackQPlainTextEdit_InputMethodQuery(const_cast<MyQPlainTextEdit*>(this), property)); };
	void insertFromMimeData(const QMimeData * source) { callbackQPlainTextEdit_InsertFromMimeData(this, const_cast<QMimeData*>(source)); };
	void insertPlainText(const QString & text) { callbackQPlainTextEdit_InsertPlainText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void keyPressEvent(QKeyEvent * e) { callbackQPlainTextEdit_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQPlainTextEdit_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) { callbackQPlainTextEdit_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQPlainTextEdit_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQPlainTextEdit_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQPlainTextEdit_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQPlainTextEdit_PaintEvent(this, e); };
	void paste() { callbackQPlainTextEdit_Paste(this); };
	void Signal_RedoAvailable(bool available) { callbackQPlainTextEdit_RedoAvailable(this, available); };
	void resizeEvent(QResizeEvent * e) { callbackQPlainTextEdit_ResizeEvent(this, e); };
	void scrollContentsBy(int dx, int dy) { callbackQPlainTextEdit_ScrollContentsBy(this, dx, dy); };
	void selectAll() { callbackQPlainTextEdit_SelectAll(this); };
	void Signal_SelectionChanged() { callbackQPlainTextEdit_SelectionChanged(this); };
	void setPlainText(const QString & text) { callbackQPlainTextEdit_SetPlainText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * vqs) { callbackQPlainTextEdit_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) { callbackQPlainTextEdit_WheelEvent(this, e); };
	 ~MyQPlainTextEdit() { callbackQPlainTextEdit_DestroyQPlainTextEdit(this); };
	bool viewportEvent(QEvent * event) { return callbackQPlainTextEdit_ViewportEvent(this, event) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQPlainTextEdit_MinimumSizeHint(const_cast<MyQPlainTextEdit*>(this))); };
	void setupViewport(QWidget * viewport) { callbackQPlainTextEdit_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQPlainTextEdit_SizeHint(const_cast<MyQPlainTextEdit*>(this))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQPlainTextEdit_ViewportSizeHint(const_cast<MyQPlainTextEdit*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQPlainTextEdit_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQPlainTextEdit_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQPlainTextEdit_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQPlainTextEdit_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQPlainTextEdit_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQPlainTextEdit_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQPlainTextEdit_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQPlainTextEdit_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQPlainTextEdit_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQPlainTextEdit_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQPlainTextEdit_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQPlainTextEdit_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQPlainTextEdit_HasHeightForWidth(const_cast<MyQPlainTextEdit*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQPlainTextEdit_HeightForWidth(const_cast<MyQPlainTextEdit*>(this), w); };
	void hide() { callbackQPlainTextEdit_Hide(this); };
	void lower() { callbackQPlainTextEdit_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQPlainTextEdit_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQPlainTextEdit_Raise(this); };
	void repaint() { callbackQPlainTextEdit_Repaint(this); };
	void setDisabled(bool disable) { callbackQPlainTextEdit_SetDisabled(this, disable); };
	void setFocus() { callbackQPlainTextEdit_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQPlainTextEdit_SetHidden(this, hidden); };
	void show() { callbackQPlainTextEdit_Show(this); };
	void showFullScreen() { callbackQPlainTextEdit_ShowFullScreen(this); };
	void showMaximized() { callbackQPlainTextEdit_ShowMaximized(this); };
	void showMinimized() { callbackQPlainTextEdit_ShowMinimized(this); };
	void showNormal() { callbackQPlainTextEdit_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQPlainTextEdit_TabletEvent(this, event); };
	void update() { callbackQPlainTextEdit_Update(this); };
	void updateMicroFocus() { callbackQPlainTextEdit_UpdateMicroFocus(this); };
	void timerEvent(QTimerEvent * event) { callbackQPlainTextEdit_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQPlainTextEdit_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQPlainTextEdit_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQPlainTextEdit_CustomEvent(this, event); };
	void deleteLater() { callbackQPlainTextEdit_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQPlainTextEdit_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQPlainTextEdit_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQPlainTextEdit_MetaObject(const_cast<MyQPlainTextEdit*>(this))); };
};

char QPlainTextEdit_BackgroundVisible(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->backgroundVisible();
}

int QPlainTextEdit_BlockCount(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->blockCount();
}

char QPlainTextEdit_CenterOnScroll(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->centerOnScroll();
}

void QPlainTextEdit_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QPlainTextEdit_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

int QPlainTextEdit_CursorWidth(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->cursorWidth();
}

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_IsReadOnly(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->isReadOnly();
}

long long QPlainTextEdit_LineWrapMode(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->lineWrapMode();
}

char QPlainTextEdit_OverwriteMode(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->overwriteMode();
}

char* QPlainTextEdit_PlaceholderText(void* ptr)
{
	return const_cast<char*>(static_cast<QPlainTextEdit*>(ptr)->placeholderText().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QPlainTextEdit_Redo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "redo");
}

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_SetCursorWidth(void* ptr, int width)
{
	static_cast<QPlainTextEdit*>(ptr)->setCursorWidth(width);
}

void QPlainTextEdit_SetLineWrapMode(void* ptr, long long mode)
{
	static_cast<QPlainTextEdit*>(ptr)->setLineWrapMode(static_cast<QPlainTextEdit::LineWrapMode>(mode));
}

void QPlainTextEdit_SetOverwriteMode(void* ptr, char overwrite)
{
	static_cast<QPlainTextEdit*>(ptr)->setOverwriteMode(overwrite != 0);
}

void QPlainTextEdit_SetPlaceholderText(void* ptr, char* placeholderText)
{
	static_cast<QPlainTextEdit*>(ptr)->setPlaceholderText(QString(placeholderText));
}

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_SetTabStopWidth(void* ptr, int width)
{
	static_cast<QPlainTextEdit*>(ptr)->setTabStopWidth(width);
}

void QPlainTextEdit_SetTextInteractionFlags(void* ptr, long long flags)
{
	static_cast<QPlainTextEdit*>(ptr)->setTextInteractionFlags(static_cast<Qt::TextInteractionFlag>(flags));
}

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();
}

int QPlainTextEdit_TabStopWidth(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->tabStopWidth();
}

long long QPlainTextEdit_TextInteractionFlags(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->textInteractionFlags();
}

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_ZoomOut(void* ptr, int ran)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "zoomOut", Q_ARG(int, ran));
}

void* QPlainTextEdit_NewQPlainTextEdit(void* parent)
{
	return new MyQPlainTextEdit(static_cast<QWidget*>(parent));
}

void* QPlainTextEdit_NewQPlainTextEdit2(char* text, void* parent)
{
	return new MyQPlainTextEdit(QString(text), static_cast<QWidget*>(parent));
}

char* QPlainTextEdit_AnchorAt(void* ptr, void* pos)
{
	return const_cast<char*>(static_cast<QPlainTextEdit*>(ptr)->anchorAt(*static_cast<QPoint*>(pos)).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QPlainTextEdit_AppendHtml(void* ptr, char* html)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "appendHtml", Q_ARG(QString, QString(html)));
}

void QPlainTextEdit_AppendPlainText(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "appendPlainText", Q_ARG(QString, QString(text)));
}

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()); });
}

void QPlainTextEdit_ConnectBlockCountChanged(void* ptr)
{
	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));
}

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_ChangeEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QPlainTextEdit_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::changeEvent(static_cast<QEvent*>(e));
}

void QPlainTextEdit_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "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_ConnectCopyAvailable(void* ptr)
{
	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));
}

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_CursorForPosition(void* ptr, void* pos)
{
	return new QTextCursor(static_cast<QPlainTextEdit*>(ptr)->cursorForPosition(*static_cast<QPoint*>(pos)));
}

void QPlainTextEdit_ConnectCursorPositionChanged(void* ptr)
{
	QObject::connect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)()>(&QPlainTextEdit::cursorPositionChanged), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)()>(&MyQPlainTextEdit::Signal_CursorPositionChanged));
}

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_CursorRect2(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QPlainTextEdit*>(ptr)->cursorRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

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_Cut(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "cut");
}

void* QPlainTextEdit_Document(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->document();
}

char* QPlainTextEdit_DocumentTitle(void* ptr)
{
	return const_cast<char*>(static_cast<QPlainTextEdit*>(ptr)->documentTitle().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QPlainTextEdit_DragEnterEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(e));
}

void QPlainTextEdit_DragEnterEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(e));
}

void QPlainTextEdit_DragLeaveEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QPlainTextEdit_DragLeaveEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QPlainTextEdit_DragMoveEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

void QPlainTextEdit_DragMoveEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

void QPlainTextEdit_DropEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->dropEvent(static_cast<QDropEvent*>(e));
}

void QPlainTextEdit_DropEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::dropEvent(static_cast<QDropEvent*>(e));
}

void QPlainTextEdit_EnsureCursorVisible(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->ensureCursorVisible();
}

char QPlainTextEdit_Find(void* ptr, char* exp, long long options)
{
	return static_cast<QPlainTextEdit*>(ptr)->find(QString(exp), static_cast<QTextDocument::FindFlag>(options));
}

void* QPlainTextEdit_FirstVisibleBlock(void* ptr)
{
	return new QTextBlock(static_cast<QPlainTextEdit*>(ptr)->firstVisibleBlock());
}

void QPlainTextEdit_FocusInEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(e));
}

void QPlainTextEdit_FocusInEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::focusInEvent(static_cast<QFocusEvent*>(e));
}

char QPlainTextEdit_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QPlainTextEdit*>(ptr)->focusNextPrevChild(next != 0);
}

char QPlainTextEdit_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::focusNextPrevChild(next != 0);
}

void QPlainTextEdit_FocusOutEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QPlainTextEdit_FocusOutEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QPlainTextEdit_InputMethodEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(e));
}

void QPlainTextEdit_InputMethodEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(e));
}

void* QPlainTextEdit_InputMethodQuery(void* ptr, long long property)
{
	return new QVariant(static_cast<QPlainTextEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(property)));
}

void* QPlainTextEdit_InputMethodQueryDefault(void* ptr, long long property)
{
	return new QVariant(static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(property)));
}

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, char* text)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "insertPlainText", Q_ARG(QString, QString(text)));
}

char QPlainTextEdit_IsUndoRedoEnabled(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->isUndoRedoEnabled();
}

void QPlainTextEdit_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QPlainTextEdit_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QPlainTextEdit_KeyReleaseEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QPlainTextEdit_KeyReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

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)
{
	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));
}

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_MouseDoubleClickEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QPlainTextEdit_MouseDoubleClickEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QPlainTextEdit_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QPlainTextEdit_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QPlainTextEdit_MousePressEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QPlainTextEdit_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QPlainTextEdit_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QPlainTextEdit_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

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));
}

void QPlainTextEdit_PaintEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->paintEvent(static_cast<QPaintEvent*>(e));
}

void QPlainTextEdit_PaintEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::paintEvent(static_cast<QPaintEvent*>(e));
}

void QPlainTextEdit_Paste(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "paste");
}

void QPlainTextEdit_Print(void* ptr, void* printer)
{
#ifndef Q_OS_IOS
	static_cast<QPlainTextEdit*>(ptr)->print(static_cast<QPagedPaintDevice*>(printer));
#endif
}

void QPlainTextEdit_ConnectRedoAvailable(void* ptr)
{
	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));
}

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_ResizeEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(e));
}

void QPlainTextEdit_ResizeEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::resizeEvent(static_cast<QResizeEvent*>(e));
}

void QPlainTextEdit_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QPlainTextEdit*>(ptr)->scrollContentsBy(dx, dy);
}

void QPlainTextEdit_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::scrollContentsBy(dx, dy);
}

void QPlainTextEdit_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "selectAll");
}

void QPlainTextEdit_ConnectSelectionChanged(void* ptr)
{
	QObject::connect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)()>(&QPlainTextEdit::selectionChanged), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)()>(&MyQPlainTextEdit::Signal_SelectionChanged));
}

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_SetCurrentCharFormat(void* ptr, void* format)
{
	static_cast<QPlainTextEdit*>(ptr)->setCurrentCharFormat(*static_cast<QTextCharFormat*>(format));
}

void QPlainTextEdit_SetDocument(void* ptr, void* document)
{
	static_cast<QPlainTextEdit*>(ptr)->setDocument(static_cast<QTextDocument*>(document));
}

void QPlainTextEdit_SetDocumentTitle(void* ptr, char* title)
{
	static_cast<QPlainTextEdit*>(ptr)->setDocumentTitle(QString(title));
}

void QPlainTextEdit_SetMaximumBlockCount(void* ptr, int maximum)
{
	static_cast<QPlainTextEdit*>(ptr)->setMaximumBlockCount(maximum);
}

void QPlainTextEdit_SetPlainText(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setPlainText", Q_ARG(QString, QString(text)));
}

void QPlainTextEdit_SetTextCursor(void* ptr, void* cursor)
{
	static_cast<QPlainTextEdit*>(ptr)->setTextCursor(*static_cast<QTextCursor*>(cursor));
}

void QPlainTextEdit_SetUndoRedoEnabled(void* ptr, char enable)
{
	static_cast<QPlainTextEdit*>(ptr)->setUndoRedoEnabled(enable != 0);
}

void QPlainTextEdit_ShowEvent(void* ptr, void* vqs)
{
	static_cast<QPlainTextEdit*>(ptr)->showEvent(static_cast<QShowEvent*>(vqs));
}

void QPlainTextEdit_ShowEventDefault(void* ptr, void* vqs)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::showEvent(static_cast<QShowEvent*>(vqs));
}

void QPlainTextEdit_ConnectTextChanged(void* ptr)
{
	QObject::connect(static_cast<QPlainTextEdit*>(ptr), static_cast<void (QPlainTextEdit::*)()>(&QPlainTextEdit::textChanged), static_cast<MyQPlainTextEdit*>(ptr), static_cast<void (MyQPlainTextEdit::*)()>(&MyQPlainTextEdit::Signal_TextChanged));
}

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());
}

char* QPlainTextEdit_ToPlainText(void* ptr)
{
	return const_cast<char*>(static_cast<QPlainTextEdit*>(ptr)->toPlainText().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QPlainTextEdit_Undo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "undo");
}

void QPlainTextEdit_ConnectUndoAvailable(void* ptr)
{
	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));
}

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)
{
	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));
}

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);
}

void QPlainTextEdit_WheelEvent(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QPlainTextEdit_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QPlainTextEdit_DestroyQPlainTextEdit(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->~QPlainTextEdit();
}

void QPlainTextEdit_DestroyQPlainTextEditDefault(void* ptr)
{

}

char QPlainTextEdit_ViewportEvent(void* ptr, void* event)
{
	return static_cast<QPlainTextEdit*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}

char QPlainTextEdit_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::viewportEvent(static_cast<QEvent*>(event));
}

void* QPlainTextEdit_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QPlainTextEdit*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QPlainTextEdit_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QPlainTextEdit_SetupViewport(void* ptr, void* viewport)
{
	static_cast<QPlainTextEdit*>(ptr)->setupViewport(static_cast<QWidget*>(viewport));
}

void QPlainTextEdit_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setupViewport(static_cast<QWidget*>(viewport));
}

void* QPlainTextEdit_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QPlainTextEdit*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QPlainTextEdit_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QPlainTextEdit_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QPlainTextEdit*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QPlainTextEdit_ViewportSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QPlainTextEdit_ActionEvent(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QPlainTextEdit_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::actionEvent(static_cast<QActionEvent*>(event));
}

void QPlainTextEdit_EnterEvent(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QPlainTextEdit_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::enterEvent(static_cast<QEvent*>(event));
}

void QPlainTextEdit_HideEvent(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QPlainTextEdit_HideEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::hideEvent(static_cast<QHideEvent*>(event));
}

void QPlainTextEdit_LeaveEvent(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QPlainTextEdit_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::leaveEvent(static_cast<QEvent*>(event));
}

void QPlainTextEdit_MoveEvent(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QPlainTextEdit_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::moveEvent(static_cast<QMoveEvent*>(event));
}

void QPlainTextEdit_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QPlainTextEdit_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setEnabled(vbo != 0);
}

void QPlainTextEdit_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QPlainTextEdit_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setStyleSheet(QString(styleSheet));
}

void QPlainTextEdit_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QPlainTextEdit_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setVisible(visible != 0);
}

void QPlainTextEdit_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QPlainTextEdit_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setWindowModified(vbo != 0);
}

void QPlainTextEdit_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QPlainTextEdit_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setWindowTitle(QString(vqs));
}

char QPlainTextEdit_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QPlainTextEdit_CloseDefault(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::close();
}

void QPlainTextEdit_CloseEvent(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QPlainTextEdit_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::closeEvent(static_cast<QCloseEvent*>(event));
}

char QPlainTextEdit_HasHeightForWidth(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->hasHeightForWidth();
}

char QPlainTextEdit_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::hasHeightForWidth();
}

int QPlainTextEdit_HeightForWidth(void* ptr, int w)
{
	return static_cast<QPlainTextEdit*>(ptr)->heightForWidth(w);
}

int QPlainTextEdit_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::heightForWidth(w);
}

void QPlainTextEdit_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "hide");
}

void QPlainTextEdit_HideDefault(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::hide();
}

void QPlainTextEdit_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "lower");
}

void QPlainTextEdit_LowerDefault(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::lower();
}

char QPlainTextEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QPlainTextEdit*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QPlainTextEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QPlainTextEdit_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "raise");
}

void QPlainTextEdit_RaiseDefault(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::raise();
}

void QPlainTextEdit_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "repaint");
}

void QPlainTextEdit_RepaintDefault(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::repaint();
}

void QPlainTextEdit_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QPlainTextEdit_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setDisabled(disable != 0);
}

void QPlainTextEdit_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setFocus");
}

void QPlainTextEdit_SetFocus2Default(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setFocus();
}

void QPlainTextEdit_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QPlainTextEdit_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setHidden(hidden != 0);
}

void QPlainTextEdit_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "show");
}

void QPlainTextEdit_ShowDefault(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::show();
}

void QPlainTextEdit_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "showFullScreen");
}

void QPlainTextEdit_ShowFullScreenDefault(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::showFullScreen();
}

void QPlainTextEdit_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "showMaximized");
}

void QPlainTextEdit_ShowMaximizedDefault(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::showMaximized();
}

void QPlainTextEdit_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "showMinimized");
}

void QPlainTextEdit_ShowMinimizedDefault(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::showMinimized();
}

void QPlainTextEdit_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "showNormal");
}

void QPlainTextEdit_ShowNormalDefault(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::showNormal();
}

void QPlainTextEdit_TabletEvent(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QPlainTextEdit_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QPlainTextEdit_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "update");
}

void QPlainTextEdit_UpdateDefault(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::update();
}

void QPlainTextEdit_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "updateMicroFocus");
}

void QPlainTextEdit_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::updateMicroFocus();
}

void QPlainTextEdit_TimerEvent(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QPlainTextEdit_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::timerEvent(static_cast<QTimerEvent*>(event));
}

void QPlainTextEdit_ChildEvent(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QPlainTextEdit_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::childEvent(static_cast<QChildEvent*>(event));
}

void QPlainTextEdit_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QPlainTextEdit*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPlainTextEdit_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPlainTextEdit_CustomEvent(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QPlainTextEdit_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::customEvent(static_cast<QEvent*>(event));
}

void QPlainTextEdit_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "deleteLater");
}

void QPlainTextEdit_DeleteLaterDefault(void* ptr)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::deleteLater();
}

void QPlainTextEdit_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QPlainTextEdit*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPlainTextEdit_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QPlainTextEdit_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QPlainTextEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QPlainTextEdit_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QPlainTextEdit_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QPlainTextEdit*>(ptr)->metaObject());
}

void* QPlainTextEdit_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::metaObject());
}

class MyQProgressBar: public QProgressBar
{
public:
	MyQProgressBar(QWidget *parent) : QProgressBar(parent) {};
	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 setValue(int value) { callbackQProgressBar_SetValue(this, value); };
	QString text() const { return QString(callbackQProgressBar_Text(const_cast<MyQProgressBar*>(this))); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQProgressBar_MinimumSizeHint(const_cast<MyQProgressBar*>(this))); };
	void paintEvent(QPaintEvent * vqp) { callbackQProgressBar_PaintEvent(this, vqp); };
	void reset() { callbackQProgressBar_Reset(this); };
	void setRange(int minimum, int maximum) { callbackQProgressBar_SetRange(this, minimum, maximum); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQProgressBar_SizeHint(const_cast<MyQProgressBar*>(this))); };
	void Signal_ValueChanged(int value) { callbackQProgressBar_ValueChanged(this, value); };
	void actionEvent(QActionEvent * event) { callbackQProgressBar_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQProgressBar_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQProgressBar_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQProgressBar_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQProgressBar_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQProgressBar_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQProgressBar_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQProgressBar_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQProgressBar_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQProgressBar_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQProgressBar_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQProgressBar_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQProgressBar_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQProgressBar_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQProgressBar_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQProgressBar_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQProgressBar_ShowEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQProgressBar_ChangeEvent(this, event); };
	bool close() { return callbackQProgressBar_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQProgressBar_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQProgressBar_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQProgressBar_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQProgressBar_HasHeightForWidth(const_cast<MyQProgressBar*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQProgressBar_HeightForWidth(const_cast<MyQProgressBar*>(this), w); };
	void hide() { callbackQProgressBar_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQProgressBar_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQProgressBar_InputMethodQuery(const_cast<MyQProgressBar*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQProgressBar_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQProgressBar_KeyReleaseEvent(this, event); };
	void lower() { callbackQProgressBar_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQProgressBar_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQProgressBar_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQProgressBar_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQProgressBar_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQProgressBar_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQProgressBar_Raise(this); };
	void repaint() { callbackQProgressBar_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQProgressBar_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQProgressBar_SetDisabled(this, disable); };
	void setFocus() { callbackQProgressBar_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQProgressBar_SetHidden(this, hidden); };
	void show() { callbackQProgressBar_Show(this); };
	void showFullScreen() { callbackQProgressBar_ShowFullScreen(this); };
	void showMaximized() { callbackQProgressBar_ShowMaximized(this); };
	void showMinimized() { callbackQProgressBar_ShowMinimized(this); };
	void showNormal() { callbackQProgressBar_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQProgressBar_TabletEvent(this, event); };
	void update() { callbackQProgressBar_Update(this); };
	void updateMicroFocus() { callbackQProgressBar_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQProgressBar_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQProgressBar_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQProgressBar_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQProgressBar_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQProgressBar_CustomEvent(this, event); };
	void deleteLater() { callbackQProgressBar_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQProgressBar_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQProgressBar_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQProgressBar_MetaObject(const_cast<MyQProgressBar*>(this))); };
};

long long QProgressBar_Alignment(void* ptr)
{
	return static_cast<QProgressBar*>(ptr)->alignment();
}

char* QProgressBar_Format(void* ptr)
{
	return const_cast<char*>(static_cast<QProgressBar*>(ptr)->format().toUtf8().prepend("WHITESPACE").constData()+10);
}

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_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, char* format)
{
	static_cast<QProgressBar*>(ptr)->setFormat(QString(format));
}

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_SetMinimum(void* ptr, int minimum)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setMinimum", Q_ARG(int, minimum));
}

void QProgressBar_SetOrientation(void* ptr, long long vqt)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setOrientation", Q_ARG(Qt::Orientation, static_cast<Qt::Orientation>(vqt)));
}

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));
}

char* QProgressBar_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QProgressBar*>(ptr)->text().toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QProgressBar_TextDefault(void* ptr)
{
	return const_cast<char*>(static_cast<QProgressBar*>(ptr)->QProgressBar::text().toUtf8().prepend("WHITESPACE").constData()+10);
}

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_NewQProgressBar(void* parent)
{
	return new MyQProgressBar(static_cast<QWidget*>(parent));
}

char QProgressBar_Event(void* ptr, void* e)
{
	return static_cast<QProgressBar*>(ptr)->event(static_cast<QEvent*>(e));
}

void QProgressBar_InitStyleOption(void* ptr, void* option)
{
	static_cast<QProgressBar*>(ptr)->initStyleOption(static_cast<QStyleOptionProgressBar*>(option));
}

void* QProgressBar_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QProgressBar*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QProgressBar_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QProgressBar*>(ptr)->QProgressBar::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QProgressBar_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QProgressBar*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QProgressBar_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QProgressBar_Reset(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "reset");
}

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_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QProgressBar*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QProgressBar_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QProgressBar*>(ptr)->QProgressBar::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QProgressBar_ConnectValueChanged(void* ptr)
{
	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));
}

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_ActionEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QProgressBar_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::actionEvent(static_cast<QActionEvent*>(event));
}

void QProgressBar_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QProgressBar_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QProgressBar_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QProgressBar_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QProgressBar_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QProgressBar_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QProgressBar_DropEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QProgressBar_DropEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::dropEvent(static_cast<QDropEvent*>(event));
}

void QProgressBar_EnterEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QProgressBar_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::enterEvent(static_cast<QEvent*>(event));
}

void QProgressBar_FocusInEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QProgressBar_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QProgressBar_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QProgressBar_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QProgressBar_HideEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QProgressBar_HideEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::hideEvent(static_cast<QHideEvent*>(event));
}

void QProgressBar_LeaveEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QProgressBar_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::leaveEvent(static_cast<QEvent*>(event));
}

void QProgressBar_MoveEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QProgressBar_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::moveEvent(static_cast<QMoveEvent*>(event));
}

void QProgressBar_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QProgressBar_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::setEnabled(vbo != 0);
}

void QProgressBar_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QProgressBar_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::setStyleSheet(QString(styleSheet));
}

void QProgressBar_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QProgressBar_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::setVisible(visible != 0);
}

void QProgressBar_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QProgressBar_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::setWindowModified(vbo != 0);
}

void QProgressBar_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QProgressBar_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::setWindowTitle(QString(vqs));
}

void QProgressBar_ShowEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QProgressBar_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::showEvent(static_cast<QShowEvent*>(event));
}

void QProgressBar_ChangeEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QProgressBar_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::changeEvent(static_cast<QEvent*>(event));
}

char QProgressBar_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QProgressBar_CloseDefault(void* ptr)
{
	return static_cast<QProgressBar*>(ptr)->QProgressBar::close();
}

void QProgressBar_CloseEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QProgressBar_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::closeEvent(static_cast<QCloseEvent*>(event));
}

void QProgressBar_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QProgressBar_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QProgressBar_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QProgressBar*>(ptr)->focusNextPrevChild(next != 0);
}

char QProgressBar_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QProgressBar*>(ptr)->QProgressBar::focusNextPrevChild(next != 0);
}

char QProgressBar_HasHeightForWidth(void* ptr)
{
	return static_cast<QProgressBar*>(ptr)->hasHeightForWidth();
}

char QProgressBar_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QProgressBar*>(ptr)->QProgressBar::hasHeightForWidth();
}

int QProgressBar_HeightForWidth(void* ptr, int w)
{
	return static_cast<QProgressBar*>(ptr)->heightForWidth(w);
}

int QProgressBar_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QProgressBar*>(ptr)->QProgressBar::heightForWidth(w);
}

void QProgressBar_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "hide");
}

void QProgressBar_HideDefault(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::hide();
}

void QProgressBar_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QProgressBar_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QProgressBar_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QProgressBar*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QProgressBar_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QProgressBar*>(ptr)->QProgressBar::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QProgressBar_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QProgressBar_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QProgressBar_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QProgressBar_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QProgressBar_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "lower");
}

void QProgressBar_LowerDefault(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::lower();
}

void QProgressBar_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QProgressBar_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QProgressBar_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QProgressBar_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QProgressBar_MousePressEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QProgressBar_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QProgressBar_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QProgressBar_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QProgressBar_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QProgressBar*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QProgressBar_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QProgressBar*>(ptr)->QProgressBar::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QProgressBar_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "raise");
}

void QProgressBar_RaiseDefault(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::raise();
}

void QProgressBar_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "repaint");
}

void QProgressBar_RepaintDefault(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::repaint();
}

void QProgressBar_ResizeEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QProgressBar_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QProgressBar_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QProgressBar_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::setDisabled(disable != 0);
}

void QProgressBar_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setFocus");
}

void QProgressBar_SetFocus2Default(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::setFocus();
}

void QProgressBar_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QProgressBar_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::setHidden(hidden != 0);
}

void QProgressBar_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "show");
}

void QProgressBar_ShowDefault(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::show();
}

void QProgressBar_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "showFullScreen");
}

void QProgressBar_ShowFullScreenDefault(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::showFullScreen();
}

void QProgressBar_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "showMaximized");
}

void QProgressBar_ShowMaximizedDefault(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::showMaximized();
}

void QProgressBar_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "showMinimized");
}

void QProgressBar_ShowMinimizedDefault(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::showMinimized();
}

void QProgressBar_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "showNormal");
}

void QProgressBar_ShowNormalDefault(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::showNormal();
}

void QProgressBar_TabletEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QProgressBar_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QProgressBar_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "update");
}

void QProgressBar_UpdateDefault(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::update();
}

void QProgressBar_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "updateMicroFocus");
}

void QProgressBar_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::updateMicroFocus();
}

void QProgressBar_WheelEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QProgressBar_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QProgressBar_TimerEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QProgressBar_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::timerEvent(static_cast<QTimerEvent*>(event));
}

void QProgressBar_ChildEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QProgressBar_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::childEvent(static_cast<QChildEvent*>(event));
}

void QProgressBar_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QProgressBar*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QProgressBar_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QProgressBar_CustomEvent(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QProgressBar_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::customEvent(static_cast<QEvent*>(event));
}

void QProgressBar_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "deleteLater");
}

void QProgressBar_DeleteLaterDefault(void* ptr)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::deleteLater();
}

void QProgressBar_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QProgressBar*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QProgressBar_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QProgressBar*>(ptr)->QProgressBar::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QProgressBar_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QProgressBar*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QProgressBar_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QProgressBar*>(ptr)->QProgressBar::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QProgressBar_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QProgressBar*>(ptr)->metaObject());
}

void* QProgressBar_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QProgressBar*>(ptr)->QProgressBar::metaObject());
}

class MyQProgressDialog: public QProgressDialog
{
public:
	MyQProgressDialog(QWidget *parent, Qt::WindowFlags f) : QProgressDialog(parent, f) {};
	MyQProgressDialog(const QString &labelText, const QString &cancelButtonText, int minimum, int maximum, QWidget *parent, Qt::WindowFlags f) : QProgressDialog(labelText, cancelButtonText, minimum, maximum, parent, f) {};
	void setLabelText(const QString & text) { callbackQProgressDialog_SetLabelText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	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 setValue(int progress) { callbackQProgressDialog_SetValue(this, progress); };
	void cancel() { callbackQProgressDialog_Cancel(this); };
	void Signal_Canceled() { callbackQProgressDialog_Canceled(this); };
	void changeEvent(QEvent * ev) { callbackQProgressDialog_ChangeEvent(this, ev); };
	void closeEvent(QCloseEvent * e) { callbackQProgressDialog_CloseEvent(this, e); };
	void forceShow() { callbackQProgressDialog_ForceShow(this); };
	void reset() { callbackQProgressDialog_Reset(this); };
	void resizeEvent(QResizeEvent * event) { callbackQProgressDialog_ResizeEvent(this, event); };
	void setCancelButtonText(const QString & cancelButtonText) { callbackQProgressDialog_SetCancelButtonText(this, const_cast<char*>(cancelButtonText.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setRange(int minimum, int maximum) { callbackQProgressDialog_SetRange(this, minimum, maximum); };
	void showEvent(QShowEvent * e) { callbackQProgressDialog_ShowEvent(this, e); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQProgressDialog_SizeHint(const_cast<MyQProgressDialog*>(this))); };
	void accept() { callbackQProgressDialog_Accept(this); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQProgressDialog_ContextMenuEvent(this, e); };
	void done(int r) { callbackQProgressDialog_Done(this, r); };
	int exec() { return callbackQProgressDialog_Exec(this); };
	void keyPressEvent(QKeyEvent * e) { callbackQProgressDialog_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQProgressDialog_MinimumSizeHint(const_cast<MyQProgressDialog*>(this))); };
	void reject() { callbackQProgressDialog_Reject(this); };
	void setVisible(bool visible) { callbackQProgressDialog_SetVisible(this, visible); };
	void actionEvent(QActionEvent * event) { callbackQProgressDialog_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQProgressDialog_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQProgressDialog_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQProgressDialog_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQProgressDialog_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQProgressDialog_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQProgressDialog_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQProgressDialog_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQProgressDialog_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQProgressDialog_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQProgressDialog_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQProgressDialog_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQProgressDialog_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQProgressDialog_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setWindowModified(bool vbo) { callbackQProgressDialog_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQProgressDialog_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQProgressDialog_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQProgressDialog_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQProgressDialog_HasHeightForWidth(const_cast<MyQProgressDialog*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQProgressDialog_HeightForWidth(const_cast<MyQProgressDialog*>(this), w); };
	void hide() { callbackQProgressDialog_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQProgressDialog_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQProgressDialog_InputMethodQuery(const_cast<MyQProgressDialog*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQProgressDialog_KeyReleaseEvent(this, event); };
	void lower() { callbackQProgressDialog_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQProgressDialog_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQProgressDialog_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQProgressDialog_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQProgressDialog_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQProgressDialog_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQProgressDialog_Raise(this); };
	void repaint() { callbackQProgressDialog_Repaint(this); };
	void setDisabled(bool disable) { callbackQProgressDialog_SetDisabled(this, disable); };
	void setFocus() { callbackQProgressDialog_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQProgressDialog_SetHidden(this, hidden); };
	void show() { callbackQProgressDialog_Show(this); };
	void showFullScreen() { callbackQProgressDialog_ShowFullScreen(this); };
	void showMaximized() { callbackQProgressDialog_ShowMaximized(this); };
	void showMinimized() { callbackQProgressDialog_ShowMinimized(this); };
	void showNormal() { callbackQProgressDialog_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQProgressDialog_TabletEvent(this, event); };
	void update() { callbackQProgressDialog_Update(this); };
	void updateMicroFocus() { callbackQProgressDialog_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQProgressDialog_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQProgressDialog_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQProgressDialog_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQProgressDialog_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQProgressDialog_CustomEvent(this, event); };
	void deleteLater() { callbackQProgressDialog_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQProgressDialog_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQProgressDialog_MetaObject(const_cast<MyQProgressDialog*>(this))); };
};

char QProgressDialog_AutoClose(void* ptr)
{
	return static_cast<QProgressDialog*>(ptr)->autoClose();
}

char QProgressDialog_AutoReset(void* ptr)
{
	return static_cast<QProgressDialog*>(ptr)->autoReset();
}

char* QProgressDialog_LabelText(void* ptr)
{
	return const_cast<char*>(static_cast<QProgressDialog*>(ptr)->labelText().toUtf8().prepend("WHITESPACE").constData()+10);
}

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_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_SetLabelText(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setLabelText", Q_ARG(QString, QString(text)));
}

void QProgressDialog_SetMaximum(void* ptr, int maximum)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setMaximum", Q_ARG(int, maximum));
}

void QProgressDialog_SetMinimum(void* ptr, int minimum)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setMinimum", Q_ARG(int, minimum));
}

void QProgressDialog_SetMinimumDuration(void* ptr, int ms)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setMinimumDuration", Q_ARG(int, ms));
}

void QProgressDialog_SetValue(void* ptr, int progress)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setValue", Q_ARG(int, 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_NewQProgressDialog(void* parent, long long f)
{
	return new MyQProgressDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
}

void* QProgressDialog_NewQProgressDialog2(char* labelText, char* cancelButtonText, int minimum, int maximum, void* parent, long long f)
{
	return new MyQProgressDialog(QString(labelText), QString(cancelButtonText), minimum, maximum, static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
}

void QProgressDialog_Cancel(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "cancel");
}

void QProgressDialog_ConnectCanceled(void* ptr)
{
	QObject::connect(static_cast<QProgressDialog*>(ptr), static_cast<void (QProgressDialog::*)()>(&QProgressDialog::canceled), static_cast<MyQProgressDialog*>(ptr), static_cast<void (MyQProgressDialog::*)()>(&MyQProgressDialog::Signal_Canceled));
}

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_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QProgressDialog*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QProgressDialog_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::changeEvent(static_cast<QEvent*>(ev));
}

void QProgressDialog_CloseEvent(void* ptr, void* e)
{
	static_cast<QProgressDialog*>(ptr)->closeEvent(static_cast<QCloseEvent*>(e));
}

void QProgressDialog_CloseEventDefault(void* ptr, void* e)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::closeEvent(static_cast<QCloseEvent*>(e));
}

void QProgressDialog_ForceShow(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "forceShow");
}

void QProgressDialog_Open(void* ptr, void* receiver, char* member)
{
	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_ResizeEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QProgressDialog_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::resizeEvent(static_cast<QResizeEvent*>(event));
}

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, char* cancelButtonText)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setCancelButtonText", Q_ARG(QString, QString(cancelButtonText)));
}

void QProgressDialog_SetLabel(void* ptr, void* label)
{
	static_cast<QProgressDialog*>(ptr)->setLabel(static_cast<QLabel*>(label));
}

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_ShowEvent(void* ptr, void* e)
{
	static_cast<QProgressDialog*>(ptr)->showEvent(static_cast<QShowEvent*>(e));
}

void QProgressDialog_ShowEventDefault(void* ptr, void* e)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::showEvent(static_cast<QShowEvent*>(e));
}

void* QProgressDialog_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QProgressDialog*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QProgressDialog_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QProgressDialog*>(ptr)->QProgressDialog::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QProgressDialog_DestroyQProgressDialog(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->~QProgressDialog();
}

void QProgressDialog_Accept(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "accept");
}

void QProgressDialog_AcceptDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::accept();
}

void QProgressDialog_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QProgressDialog*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QProgressDialog_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QProgressDialog_Done(void* ptr, int r)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "done", Q_ARG(int, r));
}

void QProgressDialog_DoneDefault(void* ptr, int r)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::done(r);
}

int QProgressDialog_Exec(void* ptr)
{
	int returnArg;
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "exec", Q_RETURN_ARG(int, returnArg));
	return returnArg;
}

int QProgressDialog_ExecDefault(void* ptr)
{
	return static_cast<QProgressDialog*>(ptr)->QProgressDialog::exec();
}

void QProgressDialog_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QProgressDialog*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QProgressDialog_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void* QProgressDialog_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QProgressDialog*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QProgressDialog_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QProgressDialog*>(ptr)->QProgressDialog::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QProgressDialog_Reject(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "reject");
}

void QProgressDialog_RejectDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::reject();
}

void QProgressDialog_SetVisible(void* ptr, char visible)
{
	static_cast<QProgressDialog*>(ptr)->setVisible(visible != 0);
}

void QProgressDialog_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::setVisible(visible != 0);
}

void QProgressDialog_ActionEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QProgressDialog_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::actionEvent(static_cast<QActionEvent*>(event));
}

void QProgressDialog_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QProgressDialog_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QProgressDialog_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QProgressDialog_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QProgressDialog_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QProgressDialog_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QProgressDialog_DropEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QProgressDialog_DropEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::dropEvent(static_cast<QDropEvent*>(event));
}

void QProgressDialog_EnterEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QProgressDialog_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::enterEvent(static_cast<QEvent*>(event));
}

void QProgressDialog_FocusInEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QProgressDialog_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QProgressDialog_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QProgressDialog_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QProgressDialog_HideEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QProgressDialog_HideEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::hideEvent(static_cast<QHideEvent*>(event));
}

void QProgressDialog_LeaveEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QProgressDialog_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::leaveEvent(static_cast<QEvent*>(event));
}

void QProgressDialog_MoveEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QProgressDialog_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::moveEvent(static_cast<QMoveEvent*>(event));
}

void QProgressDialog_PaintEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QProgressDialog_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::paintEvent(static_cast<QPaintEvent*>(event));
}

void QProgressDialog_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QProgressDialog_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::setEnabled(vbo != 0);
}

void QProgressDialog_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QProgressDialog_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::setStyleSheet(QString(styleSheet));
}

void QProgressDialog_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QProgressDialog_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::setWindowModified(vbo != 0);
}

void QProgressDialog_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QProgressDialog_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::setWindowTitle(QString(vqs));
}

char QProgressDialog_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QProgressDialog_CloseDefault(void* ptr)
{
	return static_cast<QProgressDialog*>(ptr)->QProgressDialog::close();
}

char QProgressDialog_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QProgressDialog*>(ptr)->focusNextPrevChild(next != 0);
}

char QProgressDialog_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QProgressDialog*>(ptr)->QProgressDialog::focusNextPrevChild(next != 0);
}

char QProgressDialog_HasHeightForWidth(void* ptr)
{
	return static_cast<QProgressDialog*>(ptr)->hasHeightForWidth();
}

char QProgressDialog_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QProgressDialog*>(ptr)->QProgressDialog::hasHeightForWidth();
}

int QProgressDialog_HeightForWidth(void* ptr, int w)
{
	return static_cast<QProgressDialog*>(ptr)->heightForWidth(w);
}

int QProgressDialog_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QProgressDialog*>(ptr)->QProgressDialog::heightForWidth(w);
}

void QProgressDialog_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "hide");
}

void QProgressDialog_HideDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::hide();
}

void QProgressDialog_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QProgressDialog_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QProgressDialog_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QProgressDialog*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QProgressDialog_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QProgressDialog*>(ptr)->QProgressDialog::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QProgressDialog_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QProgressDialog_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QProgressDialog_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "lower");
}

void QProgressDialog_LowerDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::lower();
}

void QProgressDialog_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QProgressDialog_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QProgressDialog_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QProgressDialog_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QProgressDialog_MousePressEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QProgressDialog_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QProgressDialog_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QProgressDialog_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QProgressDialog_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QProgressDialog*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QProgressDialog_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QProgressDialog*>(ptr)->QProgressDialog::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QProgressDialog_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "raise");
}

void QProgressDialog_RaiseDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::raise();
}

void QProgressDialog_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "repaint");
}

void QProgressDialog_RepaintDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::repaint();
}

void QProgressDialog_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QProgressDialog_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::setDisabled(disable != 0);
}

void QProgressDialog_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setFocus");
}

void QProgressDialog_SetFocus2Default(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::setFocus();
}

void QProgressDialog_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QProgressDialog_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::setHidden(hidden != 0);
}

void QProgressDialog_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "show");
}

void QProgressDialog_ShowDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::show();
}

void QProgressDialog_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "showFullScreen");
}

void QProgressDialog_ShowFullScreenDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::showFullScreen();
}

void QProgressDialog_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "showMaximized");
}

void QProgressDialog_ShowMaximizedDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::showMaximized();
}

void QProgressDialog_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "showMinimized");
}

void QProgressDialog_ShowMinimizedDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::showMinimized();
}

void QProgressDialog_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "showNormal");
}

void QProgressDialog_ShowNormalDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::showNormal();
}

void QProgressDialog_TabletEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QProgressDialog_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QProgressDialog_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "update");
}

void QProgressDialog_UpdateDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::update();
}

void QProgressDialog_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "updateMicroFocus");
}

void QProgressDialog_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::updateMicroFocus();
}

void QProgressDialog_WheelEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QProgressDialog_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QProgressDialog_TimerEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QProgressDialog_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::timerEvent(static_cast<QTimerEvent*>(event));
}

void QProgressDialog_ChildEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QProgressDialog_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::childEvent(static_cast<QChildEvent*>(event));
}

void QProgressDialog_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QProgressDialog*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QProgressDialog_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QProgressDialog_CustomEvent(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QProgressDialog_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::customEvent(static_cast<QEvent*>(event));
}

void QProgressDialog_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "deleteLater");
}

void QProgressDialog_DeleteLaterDefault(void* ptr)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::deleteLater();
}

void QProgressDialog_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QProgressDialog*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QProgressDialog_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QProgressDialog*>(ptr)->QProgressDialog::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void* QProgressDialog_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QProgressDialog*>(ptr)->metaObject());
}

void* QProgressDialog_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QProgressDialog*>(ptr)->QProgressDialog::metaObject());
}

class MyQProxyStyle: public QProxyStyle
{
public:
	MyQProxyStyle(QStyle *style) : QProxyStyle(style) {};
	MyQProxyStyle(const QString &key) : QProxyStyle(key) {};
	void drawComplexControl(QStyle::ComplexControl control, const QStyleOptionComplex * option, QPainter * painter, const QWidget * widget) const { callbackQProxyStyle_DrawComplexControl(const_cast<MyQProxyStyle*>(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 { callbackQProxyStyle_DrawControl(const_cast<MyQProxyStyle*>(this), element, const_cast<QStyleOption*>(option), painter, const_cast<QWidget*>(widget)); };
	void drawItemPixmap(QPainter * painter, const QRect & rect, int alignment, const QPixmap & pixmap) const { callbackQProxyStyle_DrawItemPixmap(const_cast<MyQProxyStyle*>(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 { callbackQProxyStyle_DrawItemText(const_cast<MyQProxyStyle*>(this), painter, const_cast<QRect*>(&rect), flags, const_cast<QPalette*>(&pal), enabled, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10), textRole); };
	void drawPrimitive(QStyle::PrimitiveElement element, const QStyleOption * option, QPainter * painter, const QWidget * widget) const { callbackQProxyStyle_DrawPrimitive(const_cast<MyQProxyStyle*>(this), element, const_cast<QStyleOption*>(option), painter, const_cast<QWidget*>(widget)); };
	QPixmap generatedIconPixmap(QIcon::Mode iconMode, const QPixmap & pixmap, const QStyleOption * opt) const { return *static_cast<QPixmap*>(callbackQProxyStyle_GeneratedIconPixmap(const_cast<MyQProxyStyle*>(this), iconMode, const_cast<QPixmap*>(&pixmap), const_cast<QStyleOption*>(opt))); };
	SubControl hitTestComplexControl(QStyle::ComplexControl control, const QStyleOptionComplex * option, const QPoint & pos, const QWidget * widget) const { return static_cast<QStyle::SubControl>(callbackQProxyStyle_HitTestComplexControl(const_cast<MyQProxyStyle*>(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*>(callbackQProxyStyle_ItemPixmapRect(const_cast<MyQProxyStyle*>(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 { return *static_cast<QRect*>(callbackQProxyStyle_ItemTextRect(const_cast<MyQProxyStyle*>(this), const_cast<QFontMetrics*>(&fm), const_cast<QRect*>(&r), flags, enabled, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10))); };
	int layoutSpacing(QSizePolicy::ControlType control1, QSizePolicy::ControlType control2, Qt::Orientation orientation, const QStyleOption * option, const QWidget * widget) const { return callbackQProxyStyle_LayoutSpacing(const_cast<MyQProxyStyle*>(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 callbackQProxyStyle_PixelMetric(const_cast<MyQProxyStyle*>(this), metric, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget)); };
	void polish(QApplication * app) { callbackQProxyStyle_Polish3(this, app); };
	void polish(QPalette & pal) { callbackQProxyStyle_Polish2(this, new QPalette(pal)); };
	void polish(QWidget * widget) { callbackQProxyStyle_Polish(this, widget); };
	QSize sizeFromContents(QStyle::ContentsType ty, const QStyleOption * option, const QSize & size, const QWidget * widget) const { return *static_cast<QSize*>(callbackQProxyStyle_SizeFromContents(const_cast<MyQProxyStyle*>(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<MyQProxyStyle*>(this), standardIcon, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
	QPalette standardPalette() const { return *static_cast<QPalette*>(callbackQProxyStyle_StandardPalette(const_cast<MyQProxyStyle*>(this))); };
	QPixmap standardPixmap(QStyle::StandardPixmap standardPixmap, const QStyleOption * opt, const QWidget * widget) const { return *static_cast<QPixmap*>(callbackQProxyStyle_StandardPixmap(const_cast<MyQProxyStyle*>(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 callbackQProxyStyle_StyleHint(const_cast<MyQProxyStyle*>(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*>(callbackQProxyStyle_SubControlRect(const_cast<MyQProxyStyle*>(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*>(callbackQProxyStyle_SubElementRect(const_cast<MyQProxyStyle*>(this), element, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
	void unpolish(QApplication * app) { callbackQProxyStyle_Unpolish2(this, app); };
	void unpolish(QWidget * widget) { callbackQProxyStyle_Unpolish(this, widget); };
	void timerEvent(QTimerEvent * event) { callbackQProxyStyle_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQProxyStyle_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQProxyStyle_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQProxyStyle_CustomEvent(this, event); };
	void deleteLater() { callbackQProxyStyle_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQProxyStyle_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQProxyStyle_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQProxyStyle_MetaObject(const_cast<MyQProxyStyle*>(this))); };
};

void* QProxyStyle_NewQProxyStyle(void* style)
{
	return new MyQProxyStyle(static_cast<QStyle*>(style));
}

void* QProxyStyle_NewQProxyStyle2(char* key)
{
	return new MyQProxyStyle(QString(key));
}

void* QProxyStyle_BaseStyle(void* ptr)
{
	return static_cast<QProxyStyle*>(ptr)->baseStyle();
}

void QProxyStyle_DrawComplexControl(void* ptr, long long control, void* option, void* painter, void* widget)
{
	static_cast<QProxyStyle*>(ptr)->drawComplexControl(static_cast<QStyle::ComplexControl>(control), static_cast<QStyleOptionComplex*>(option), static_cast<QPainter*>(painter), static_cast<QWidget*>(widget));
}

void QProxyStyle_DrawComplexControlDefault(void* ptr, long long control, void* option, void* painter, void* widget)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::drawComplexControl(static_cast<QStyle::ComplexControl>(control), static_cast<QStyleOptionComplex*>(option), static_cast<QPainter*>(painter), static_cast<QWidget*>(widget));
}

void QProxyStyle_DrawControl(void* ptr, long long element, void* option, void* painter, void* widget)
{
	static_cast<QProxyStyle*>(ptr)->drawControl(static_cast<QStyle::ControlElement>(element), static_cast<QStyleOption*>(option), static_cast<QPainter*>(painter), static_cast<QWidget*>(widget));
}

void QProxyStyle_DrawControlDefault(void* ptr, long long element, void* option, void* painter, void* widget)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::drawControl(static_cast<QStyle::ControlElement>(element), static_cast<QStyleOption*>(option), static_cast<QPainter*>(painter), static_cast<QWidget*>(widget));
}

void QProxyStyle_DrawItemPixmap(void* ptr, void* painter, void* rect, int alignment, void* pixmap)
{
	static_cast<QProxyStyle*>(ptr)->drawItemPixmap(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), alignment, *static_cast<QPixmap*>(pixmap));
}

void QProxyStyle_DrawItemPixmapDefault(void* ptr, void* painter, void* rect, int alignment, void* pixmap)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::drawItemPixmap(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), alignment, *static_cast<QPixmap*>(pixmap));
}

void QProxyStyle_DrawItemText(void* ptr, void* painter, void* rect, int flags, void* pal, char enabled, char* text, long long textRole)
{
	static_cast<QProxyStyle*>(ptr)->drawItemText(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), flags, *static_cast<QPalette*>(pal), enabled != 0, QString(text), static_cast<QPalette::ColorRole>(textRole));
}

void QProxyStyle_DrawItemTextDefault(void* ptr, void* painter, void* rect, int flags, void* pal, char enabled, char* text, long long textRole)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::drawItemText(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), flags, *static_cast<QPalette*>(pal), enabled != 0, QString(text), static_cast<QPalette::ColorRole>(textRole));
}

void QProxyStyle_DrawPrimitive(void* ptr, long long element, void* option, void* painter, void* widget)
{
	static_cast<QProxyStyle*>(ptr)->drawPrimitive(static_cast<QStyle::PrimitiveElement>(element), static_cast<QStyleOption*>(option), static_cast<QPainter*>(painter), static_cast<QWidget*>(widget));
}

void QProxyStyle_DrawPrimitiveDefault(void* ptr, long long element, void* option, void* painter, void* widget)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::drawPrimitive(static_cast<QStyle::PrimitiveElement>(element), static_cast<QStyleOption*>(option), static_cast<QPainter*>(painter), static_cast<QWidget*>(widget));
}

char QProxyStyle_Event(void* ptr, void* e)
{
	return static_cast<QProxyStyle*>(ptr)->event(static_cast<QEvent*>(e));
}

void* QProxyStyle_GeneratedIconPixmap(void* ptr, long long iconMode, void* pixmap, void* opt)
{
	return new QPixmap(static_cast<QProxyStyle*>(ptr)->generatedIconPixmap(static_cast<QIcon::Mode>(iconMode), *static_cast<QPixmap*>(pixmap), static_cast<QStyleOption*>(opt)));
}

void* QProxyStyle_GeneratedIconPixmapDefault(void* ptr, long long iconMode, void* pixmap, void* opt)
{
	return new QPixmap(static_cast<QProxyStyle*>(ptr)->QProxyStyle::generatedIconPixmap(static_cast<QIcon::Mode>(iconMode), *static_cast<QPixmap*>(pixmap), static_cast<QStyleOption*>(opt)));
}

long long QProxyStyle_HitTestComplexControl(void* ptr, long long control, void* option, void* pos, void* widget)
{
	return static_cast<QProxyStyle*>(ptr)->hitTestComplexControl(static_cast<QStyle::ComplexControl>(control), static_cast<QStyleOptionComplex*>(option), *static_cast<QPoint*>(pos), static_cast<QWidget*>(widget));
}

long long QProxyStyle_HitTestComplexControlDefault(void* ptr, long long control, void* option, void* pos, void* widget)
{
	return static_cast<QProxyStyle*>(ptr)->QProxyStyle::hitTestComplexControl(static_cast<QStyle::ComplexControl>(control), static_cast<QStyleOptionComplex*>(option), *static_cast<QPoint*>(pos), static_cast<QWidget*>(widget));
}

void* QProxyStyle_ItemPixmapRect(void* ptr, void* r, int flags, void* pixmap)
{
	return ({ QRect tmpValue = static_cast<QProxyStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(r), flags, *static_cast<QPixmap*>(pixmap)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QProxyStyle_ItemPixmapRectDefault(void* ptr, void* r, int flags, void* pixmap)
{
	return ({ QRect tmpValue = static_cast<QProxyStyle*>(ptr)->QProxyStyle::itemPixmapRect(*static_cast<QRect*>(r), flags, *static_cast<QPixmap*>(pixmap)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QProxyStyle_ItemTextRect(void* ptr, void* fm, void* r, int flags, char enabled, char* text)
{
	return ({ QRect tmpValue = static_cast<QProxyStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(fm), *static_cast<QRect*>(r), flags, enabled != 0, QString(text)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QProxyStyle_ItemTextRectDefault(void* ptr, void* fm, void* r, int flags, char enabled, char* text)
{
	return ({ QRect tmpValue = static_cast<QProxyStyle*>(ptr)->QProxyStyle::itemTextRect(*static_cast<QFontMetrics*>(fm), *static_cast<QRect*>(r), flags, enabled != 0, QString(text)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

int QProxyStyle_LayoutSpacing(void* ptr, long long control1, long long control2, long long orientation, void* option, void* widget)
{
	return static_cast<QProxyStyle*>(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 QProxyStyle_LayoutSpacingDefault(void* ptr, long long control1, long long control2, long long orientation, void* option, void* widget)
{
	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));
}

int QProxyStyle_PixelMetric(void* ptr, long long metric, void* option, void* widget)
{
	return static_cast<QProxyStyle*>(ptr)->pixelMetric(static_cast<QStyle::PixelMetric>(metric), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget));
}

int QProxyStyle_PixelMetricDefault(void* ptr, long long metric, void* option, void* widget)
{
	return static_cast<QProxyStyle*>(ptr)->QProxyStyle::pixelMetric(static_cast<QStyle::PixelMetric>(metric), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget));
}

void QProxyStyle_Polish3(void* ptr, void* app)
{
	static_cast<QProxyStyle*>(ptr)->polish(static_cast<QApplication*>(app));
}

void QProxyStyle_Polish3Default(void* ptr, void* app)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::polish(static_cast<QApplication*>(app));
}

void QProxyStyle_Polish2(void* ptr, void* pal)
{
	static_cast<QProxyStyle*>(ptr)->polish(*static_cast<QPalette*>(pal));
}

void QProxyStyle_Polish2Default(void* ptr, void* pal)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::polish(*static_cast<QPalette*>(pal));
}

void QProxyStyle_Polish(void* ptr, void* widget)
{
	static_cast<QProxyStyle*>(ptr)->polish(static_cast<QWidget*>(widget));
}

void QProxyStyle_PolishDefault(void* ptr, void* widget)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::polish(static_cast<QWidget*>(widget));
}

void QProxyStyle_SetBaseStyle(void* ptr, void* style)
{
	static_cast<QProxyStyle*>(ptr)->setBaseStyle(static_cast<QStyle*>(style));
}

void* QProxyStyle_SizeFromContents(void* ptr, long long ty, void* option, void* size, void* widget)
{
	return ({ QSize tmpValue = static_cast<QProxyStyle*>(ptr)->sizeFromContents(static_cast<QStyle::ContentsType>(ty), static_cast<QStyleOption*>(option), *static_cast<QSize*>(size), static_cast<QWidget*>(widget)); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QProxyStyle_SizeFromContentsDefault(void* ptr, long long ty, void* option, void* size, void* widget)
{
	return ({ QSize tmpValue = static_cast<QProxyStyle*>(ptr)->QProxyStyle::sizeFromContents(static_cast<QStyle::ContentsType>(ty), static_cast<QStyleOption*>(option), *static_cast<QSize*>(size), static_cast<QWidget*>(widget)); new QSize(tmpValue.width(), tmpValue.height()); });
}

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_StandardPalette(void* ptr)
{
	return new QPalette(static_cast<QProxyStyle*>(ptr)->standardPalette());
}

void* QProxyStyle_StandardPaletteDefault(void* ptr)
{
	return new QPalette(static_cast<QProxyStyle*>(ptr)->QProxyStyle::standardPalette());
}

void* QProxyStyle_StandardPixmap(void* ptr, long long standardPixmap, void* opt, void* widget)
{
	return new QPixmap(static_cast<QProxyStyle*>(ptr)->standardPixmap(static_cast<QStyle::StandardPixmap>(standardPixmap), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget)));
}

void* QProxyStyle_StandardPixmapDefault(void* ptr, long long standardPixmap, void* opt, void* widget)
{
	return new QPixmap(static_cast<QProxyStyle*>(ptr)->QProxyStyle::standardPixmap(static_cast<QStyle::StandardPixmap>(standardPixmap), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget)));
}

int QProxyStyle_StyleHint(void* ptr, long long hint, void* option, void* widget, void* returnData)
{
	return static_cast<QProxyStyle*>(ptr)->styleHint(static_cast<QStyle::StyleHint>(hint), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget), static_cast<QStyleHintReturn*>(returnData));
}

int QProxyStyle_StyleHintDefault(void* ptr, long long hint, void* option, void* widget, void* returnData)
{
	return static_cast<QProxyStyle*>(ptr)->QProxyStyle::styleHint(static_cast<QStyle::StyleHint>(hint), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget), static_cast<QStyleHintReturn*>(returnData));
}

void* QProxyStyle_SubControlRect(void* ptr, long long cc, void* option, long long sc, void* widget)
{
	return ({ QRect tmpValue = static_cast<QProxyStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QProxyStyle_SubControlRectDefault(void* ptr, long long cc, void* option, long long sc, void* widget)
{
	return ({ QRect tmpValue = static_cast<QProxyStyle*>(ptr)->QProxyStyle::subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QProxyStyle_SubElementRect(void* ptr, long long element, void* option, void* widget)
{
	return ({ QRect tmpValue = static_cast<QProxyStyle*>(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* QProxyStyle_SubElementRectDefault(void* ptr, long long element, void* option, void* widget)
{
	return ({ QRect tmpValue = static_cast<QProxyStyle*>(ptr)->QProxyStyle::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 QProxyStyle_Unpolish2(void* ptr, void* app)
{
	static_cast<QProxyStyle*>(ptr)->unpolish(static_cast<QApplication*>(app));
}

void QProxyStyle_Unpolish2Default(void* ptr, void* app)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::unpolish(static_cast<QApplication*>(app));
}

void QProxyStyle_Unpolish(void* ptr, void* widget)
{
	static_cast<QProxyStyle*>(ptr)->unpolish(static_cast<QWidget*>(widget));
}

void QProxyStyle_UnpolishDefault(void* ptr, void* widget)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::unpolish(static_cast<QWidget*>(widget));
}

void QProxyStyle_DestroyQProxyStyle(void* ptr)
{
	static_cast<QProxyStyle*>(ptr)->~QProxyStyle();
}

void QProxyStyle_TimerEvent(void* ptr, void* event)
{
	static_cast<QProxyStyle*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QProxyStyle_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::timerEvent(static_cast<QTimerEvent*>(event));
}

void QProxyStyle_ChildEvent(void* ptr, void* event)
{
	static_cast<QProxyStyle*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QProxyStyle_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::childEvent(static_cast<QChildEvent*>(event));
}

void QProxyStyle_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QProxyStyle*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QProxyStyle_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QProxyStyle_CustomEvent(void* ptr, void* event)
{
	static_cast<QProxyStyle*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QProxyStyle_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::customEvent(static_cast<QEvent*>(event));
}

void QProxyStyle_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QProxyStyle*>(ptr), "deleteLater");
}

void QProxyStyle_DeleteLaterDefault(void* ptr)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::deleteLater();
}

void QProxyStyle_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QProxyStyle*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QProxyStyle_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QProxyStyle*>(ptr)->QProxyStyle::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QProxyStyle_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QProxyStyle*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QProxyStyle_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QProxyStyle*>(ptr)->QProxyStyle::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QProxyStyle_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QProxyStyle*>(ptr)->metaObject());
}

void* QProxyStyle_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::metaObject());
}

class MyQPushButton: public QPushButton
{
public:
	MyQPushButton(QWidget *parent) : QPushButton(parent) {};
	MyQPushButton(const QIcon &icon, const QString &text, QWidget *parent) : QPushButton(icon, text, parent) {};
	MyQPushButton(const QString &text, QWidget *parent) : QPushButton(text, parent) {};
	void focusInEvent(QFocusEvent * e) { callbackQPushButton_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQPushButton_FocusOutEvent(this, e); };
	bool hitButton(const QPoint & pos) const { return callbackQPushButton_HitButton(const_cast<MyQPushButton*>(this), const_cast<QPoint*>(&pos)) != 0; };
	void keyPressEvent(QKeyEvent * e) { callbackQPushButton_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQPushButton_MinimumSizeHint(const_cast<MyQPushButton*>(this))); };
	void paintEvent(QPaintEvent * vqp) { callbackQPushButton_PaintEvent(this, vqp); };
	void showMenu() { callbackQPushButton_ShowMenu(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQPushButton_SizeHint(const_cast<MyQPushButton*>(this))); };
	void setChecked(bool vbo) { callbackQPushButton_SetChecked(this, vbo); };
	void setIconSize(const QSize & size) { callbackQPushButton_SetIconSize(this, const_cast<QSize*>(&size)); };
	void toggle() { callbackQPushButton_Toggle(this); };
	void animateClick(int msec) { callbackQPushButton_AnimateClick(this, msec); };
	void changeEvent(QEvent * e) { callbackQPushButton_ChangeEvent(this, e); };
	void checkStateSet() { callbackQPushButton_CheckStateSet(this); };
	void click() { callbackQPushButton_Click(this); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQPushButton_KeyReleaseEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQPushButton_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQPushButton_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQPushButton_MouseReleaseEvent(this, e); };
	void nextCheckState() { callbackQPushButton_NextCheckState(this); };
	void actionEvent(QActionEvent * event) { callbackQPushButton_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQPushButton_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQPushButton_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQPushButton_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQPushButton_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQPushButton_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQPushButton_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQPushButton_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQPushButton_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQPushButton_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQPushButton_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQPushButton_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQPushButton_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQPushButton_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQPushButton_ShowEvent(this, event); };
	bool close() { return callbackQPushButton_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQPushButton_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQPushButton_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQPushButton_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQPushButton_HasHeightForWidth(const_cast<MyQPushButton*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQPushButton_HeightForWidth(const_cast<MyQPushButton*>(this), w); };
	void hide() { callbackQPushButton_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQPushButton_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQPushButton_InputMethodQuery(const_cast<MyQPushButton*>(this), query)); };
	void lower() { callbackQPushButton_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQPushButton_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQPushButton_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQPushButton_Raise(this); };
	void repaint() { callbackQPushButton_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQPushButton_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQPushButton_SetDisabled(this, disable); };
	void setFocus() { callbackQPushButton_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQPushButton_SetHidden(this, hidden); };
	void show() { callbackQPushButton_Show(this); };
	void showFullScreen() { callbackQPushButton_ShowFullScreen(this); };
	void showMaximized() { callbackQPushButton_ShowMaximized(this); };
	void showMinimized() { callbackQPushButton_ShowMinimized(this); };
	void showNormal() { callbackQPushButton_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQPushButton_TabletEvent(this, event); };
	void update() { callbackQPushButton_Update(this); };
	void updateMicroFocus() { callbackQPushButton_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQPushButton_WheelEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQPushButton_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQPushButton_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQPushButton_CustomEvent(this, event); };
	void deleteLater() { callbackQPushButton_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQPushButton_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQPushButton_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQPushButton_MetaObject(const_cast<MyQPushButton*>(this))); };
};

char QPushButton_AutoDefault(void* ptr)
{
	return static_cast<QPushButton*>(ptr)->autoDefault();
}

char QPushButton_IsDefault(void* ptr)
{
	return static_cast<QPushButton*>(ptr)->isDefault();
}

char QPushButton_IsFlat(void* ptr)
{
	return static_cast<QPushButton*>(ptr)->isFlat();
}

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_NewQPushButton(void* parent)
{
	return new MyQPushButton(static_cast<QWidget*>(parent));
}

void* QPushButton_NewQPushButton3(void* icon, char* text, void* parent)
{
	return new MyQPushButton(*static_cast<QIcon*>(icon), QString(text), static_cast<QWidget*>(parent));
}

void* QPushButton_NewQPushButton2(char* text, void* parent)
{
	return new MyQPushButton(QString(text), static_cast<QWidget*>(parent));
}

char QPushButton_Event(void* ptr, void* e)
{
	return static_cast<QPushButton*>(ptr)->event(static_cast<QEvent*>(e));
}

void QPushButton_FocusInEvent(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(e));
}

void QPushButton_FocusInEventDefault(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->QPushButton::focusInEvent(static_cast<QFocusEvent*>(e));
}

void QPushButton_FocusOutEvent(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QPushButton_FocusOutEventDefault(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->QPushButton::focusOutEvent(static_cast<QFocusEvent*>(e));
}

char QPushButton_HitButton(void* ptr, void* pos)
{
	return static_cast<QPushButton*>(ptr)->hitButton(*static_cast<QPoint*>(pos));
}

char QPushButton_HitButtonDefault(void* ptr, void* pos)
{
	return static_cast<QPushButton*>(ptr)->QPushButton::hitButton(*static_cast<QPoint*>(pos));
}

void QPushButton_InitStyleOption(void* ptr, void* option)
{
	static_cast<QPushButton*>(ptr)->initStyleOption(static_cast<QStyleOptionButton*>(option));
}

void QPushButton_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QPushButton_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->QPushButton::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void* QPushButton_Menu(void* ptr)
{
	return static_cast<QPushButton*>(ptr)->menu();
}

void* QPushButton_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QPushButton*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QPushButton_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QPushButton*>(ptr)->QPushButton::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QPushButton_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QPushButton*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QPushButton_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QPushButton*>(ptr)->QPushButton::paintEvent(static_cast<QPaintEvent*>(vqp));
}

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_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QPushButton*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QPushButton_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QPushButton*>(ptr)->QPushButton::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QPushButton_DestroyQPushButton(void* ptr)
{
	static_cast<QPushButton*>(ptr)->~QPushButton();
}

void QPushButton_SetChecked(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}

void QPushButton_SetCheckedDefault(void* ptr, char vbo)
{
	static_cast<QPushButton*>(ptr)->QPushButton::setChecked(vbo != 0);
}

void QPushButton_SetIconSize(void* ptr, void* size)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setIconSize", Q_ARG(QSize, *static_cast<QSize*>(size)));
}

void QPushButton_SetIconSizeDefault(void* ptr, void* size)
{
	static_cast<QPushButton*>(ptr)->QPushButton::setIconSize(*static_cast<QSize*>(size));
}

void QPushButton_Toggle(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "toggle");
}

void QPushButton_ToggleDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::toggle();
}

void QPushButton_AnimateClick(void* ptr, int msec)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "animateClick", Q_ARG(int, msec));
}

void QPushButton_AnimateClickDefault(void* ptr, int msec)
{
	static_cast<QPushButton*>(ptr)->QPushButton::animateClick(msec);
}

void QPushButton_ChangeEvent(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QPushButton_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->QPushButton::changeEvent(static_cast<QEvent*>(e));
}

void QPushButton_CheckStateSet(void* ptr)
{
	static_cast<QPushButton*>(ptr)->checkStateSet();
}

void QPushButton_CheckStateSetDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::checkStateSet();
}

void QPushButton_Click(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "click");
}

void QPushButton_ClickDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::click();
}

void QPushButton_KeyReleaseEvent(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QPushButton_KeyReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->QPushButton::keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QPushButton_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QPushButton_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->QPushButton::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QPushButton_MousePressEvent(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QPushButton_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->QPushButton::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QPushButton_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QPushButton_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QPushButton*>(ptr)->QPushButton::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QPushButton_NextCheckState(void* ptr)
{
	static_cast<QPushButton*>(ptr)->nextCheckState();
}

void QPushButton_NextCheckStateDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::nextCheckState();
}

void QPushButton_ActionEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QPushButton_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::actionEvent(static_cast<QActionEvent*>(event));
}

void QPushButton_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QPushButton_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QPushButton_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QPushButton_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QPushButton_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QPushButton_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QPushButton_DropEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QPushButton_DropEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::dropEvent(static_cast<QDropEvent*>(event));
}

void QPushButton_EnterEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QPushButton_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::enterEvent(static_cast<QEvent*>(event));
}

void QPushButton_HideEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QPushButton_HideEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::hideEvent(static_cast<QHideEvent*>(event));
}

void QPushButton_LeaveEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QPushButton_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::leaveEvent(static_cast<QEvent*>(event));
}

void QPushButton_MoveEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QPushButton_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::moveEvent(static_cast<QMoveEvent*>(event));
}

void QPushButton_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QPushButton_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QPushButton*>(ptr)->QPushButton::setEnabled(vbo != 0);
}

void QPushButton_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QPushButton_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QPushButton*>(ptr)->QPushButton::setStyleSheet(QString(styleSheet));
}

void QPushButton_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QPushButton_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QPushButton*>(ptr)->QPushButton::setVisible(visible != 0);
}

void QPushButton_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QPushButton_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QPushButton*>(ptr)->QPushButton::setWindowModified(vbo != 0);
}

void QPushButton_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QPushButton_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QPushButton*>(ptr)->QPushButton::setWindowTitle(QString(vqs));
}

void QPushButton_ShowEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QPushButton_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::showEvent(static_cast<QShowEvent*>(event));
}

char QPushButton_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QPushButton_CloseDefault(void* ptr)
{
	return static_cast<QPushButton*>(ptr)->QPushButton::close();
}

void QPushButton_CloseEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QPushButton_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::closeEvent(static_cast<QCloseEvent*>(event));
}

void QPushButton_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QPushButton_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QPushButton_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QPushButton*>(ptr)->focusNextPrevChild(next != 0);
}

char QPushButton_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QPushButton*>(ptr)->QPushButton::focusNextPrevChild(next != 0);
}

char QPushButton_HasHeightForWidth(void* ptr)
{
	return static_cast<QPushButton*>(ptr)->hasHeightForWidth();
}

char QPushButton_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QPushButton*>(ptr)->QPushButton::hasHeightForWidth();
}

int QPushButton_HeightForWidth(void* ptr, int w)
{
	return static_cast<QPushButton*>(ptr)->heightForWidth(w);
}

int QPushButton_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QPushButton*>(ptr)->QPushButton::heightForWidth(w);
}

void QPushButton_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "hide");
}

void QPushButton_HideDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::hide();
}

void QPushButton_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QPushButton_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QPushButton_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QPushButton*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QPushButton_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QPushButton*>(ptr)->QPushButton::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QPushButton_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "lower");
}

void QPushButton_LowerDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::lower();
}

void QPushButton_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QPushButton_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QPushButton_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QPushButton*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QPushButton_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QPushButton*>(ptr)->QPushButton::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QPushButton_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "raise");
}

void QPushButton_RaiseDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::raise();
}

void QPushButton_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "repaint");
}

void QPushButton_RepaintDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::repaint();
}

void QPushButton_ResizeEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QPushButton_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QPushButton_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QPushButton_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QPushButton*>(ptr)->QPushButton::setDisabled(disable != 0);
}

void QPushButton_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setFocus");
}

void QPushButton_SetFocus2Default(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::setFocus();
}

void QPushButton_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QPushButton_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QPushButton*>(ptr)->QPushButton::setHidden(hidden != 0);
}

void QPushButton_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "show");
}

void QPushButton_ShowDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::show();
}

void QPushButton_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "showFullScreen");
}

void QPushButton_ShowFullScreenDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::showFullScreen();
}

void QPushButton_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "showMaximized");
}

void QPushButton_ShowMaximizedDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::showMaximized();
}

void QPushButton_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "showMinimized");
}

void QPushButton_ShowMinimizedDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::showMinimized();
}

void QPushButton_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "showNormal");
}

void QPushButton_ShowNormalDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::showNormal();
}

void QPushButton_TabletEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QPushButton_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QPushButton_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "update");
}

void QPushButton_UpdateDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::update();
}

void QPushButton_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "updateMicroFocus");
}

void QPushButton_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::updateMicroFocus();
}

void QPushButton_WheelEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QPushButton_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QPushButton_ChildEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QPushButton_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::childEvent(static_cast<QChildEvent*>(event));
}

void QPushButton_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QPushButton*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPushButton_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QPushButton*>(ptr)->QPushButton::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPushButton_CustomEvent(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QPushButton_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QPushButton*>(ptr)->QPushButton::customEvent(static_cast<QEvent*>(event));
}

void QPushButton_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "deleteLater");
}

void QPushButton_DeleteLaterDefault(void* ptr)
{
	static_cast<QPushButton*>(ptr)->QPushButton::deleteLater();
}

void QPushButton_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QPushButton*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPushButton_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QPushButton*>(ptr)->QPushButton::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QPushButton_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QPushButton*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QPushButton_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QPushButton*>(ptr)->QPushButton::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QPushButton_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QPushButton*>(ptr)->metaObject());
}

void* QPushButton_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QPushButton*>(ptr)->QPushButton::metaObject());
}

class MyQRadioButton: public QRadioButton
{
public:
	MyQRadioButton(QWidget *parent) : QRadioButton(parent) {};
	MyQRadioButton(const QString &text, QWidget *parent) : QRadioButton(text, parent) {};
	bool hitButton(const QPoint & pos) const { return callbackQRadioButton_HitButton(const_cast<MyQRadioButton*>(this), const_cast<QPoint*>(&pos)) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQRadioButton_MinimumSizeHint(const_cast<MyQRadioButton*>(this))); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQRadioButton_MouseMoveEvent(this, e); };
	void paintEvent(QPaintEvent * vqp) { callbackQRadioButton_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQRadioButton_SizeHint(const_cast<MyQRadioButton*>(this))); };
	void setChecked(bool vbo) { callbackQRadioButton_SetChecked(this, vbo); };
	void setIconSize(const QSize & size) { callbackQRadioButton_SetIconSize(this, const_cast<QSize*>(&size)); };
	void toggle() { callbackQRadioButton_Toggle(this); };
	void animateClick(int msec) { callbackQRadioButton_AnimateClick(this, msec); };
	void changeEvent(QEvent * e) { callbackQRadioButton_ChangeEvent(this, e); };
	void checkStateSet() { callbackQRadioButton_CheckStateSet(this); };
	void click() { callbackQRadioButton_Click(this); };
	void focusInEvent(QFocusEvent * e) { callbackQRadioButton_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQRadioButton_FocusOutEvent(this, e); };
	void keyPressEvent(QKeyEvent * e) { callbackQRadioButton_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQRadioButton_KeyReleaseEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQRadioButton_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQRadioButton_MouseReleaseEvent(this, e); };
	void nextCheckState() { callbackQRadioButton_NextCheckState(this); };
	void actionEvent(QActionEvent * event) { callbackQRadioButton_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQRadioButton_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQRadioButton_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQRadioButton_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQRadioButton_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQRadioButton_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQRadioButton_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQRadioButton_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQRadioButton_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQRadioButton_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQRadioButton_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQRadioButton_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQRadioButton_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQRadioButton_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQRadioButton_ShowEvent(this, event); };
	bool close() { return callbackQRadioButton_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQRadioButton_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQRadioButton_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQRadioButton_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQRadioButton_HasHeightForWidth(const_cast<MyQRadioButton*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQRadioButton_HeightForWidth(const_cast<MyQRadioButton*>(this), w); };
	void hide() { callbackQRadioButton_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQRadioButton_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQRadioButton_InputMethodQuery(const_cast<MyQRadioButton*>(this), query)); };
	void lower() { callbackQRadioButton_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQRadioButton_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQRadioButton_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQRadioButton_Raise(this); };
	void repaint() { callbackQRadioButton_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQRadioButton_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQRadioButton_SetDisabled(this, disable); };
	void setFocus() { callbackQRadioButton_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQRadioButton_SetHidden(this, hidden); };
	void show() { callbackQRadioButton_Show(this); };
	void showFullScreen() { callbackQRadioButton_ShowFullScreen(this); };
	void showMaximized() { callbackQRadioButton_ShowMaximized(this); };
	void showMinimized() { callbackQRadioButton_ShowMinimized(this); };
	void showNormal() { callbackQRadioButton_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQRadioButton_TabletEvent(this, event); };
	void update() { callbackQRadioButton_Update(this); };
	void updateMicroFocus() { callbackQRadioButton_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQRadioButton_WheelEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQRadioButton_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQRadioButton_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQRadioButton_CustomEvent(this, event); };
	void deleteLater() { callbackQRadioButton_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQRadioButton_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQRadioButton_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQRadioButton_MetaObject(const_cast<MyQRadioButton*>(this))); };
};

void* QRadioButton_NewQRadioButton(void* parent)
{
	return new MyQRadioButton(static_cast<QWidget*>(parent));
}

void* QRadioButton_NewQRadioButton2(char* text, void* parent)
{
	return new MyQRadioButton(QString(text), static_cast<QWidget*>(parent));
}

char QRadioButton_Event(void* ptr, void* e)
{
	return static_cast<QRadioButton*>(ptr)->event(static_cast<QEvent*>(e));
}

char QRadioButton_HitButton(void* ptr, void* pos)
{
	return static_cast<QRadioButton*>(ptr)->hitButton(*static_cast<QPoint*>(pos));
}

char QRadioButton_HitButtonDefault(void* ptr, void* pos)
{
	return static_cast<QRadioButton*>(ptr)->QRadioButton::hitButton(*static_cast<QPoint*>(pos));
}

void QRadioButton_InitStyleOption(void* ptr, void* option)
{
	static_cast<QRadioButton*>(ptr)->initStyleOption(static_cast<QStyleOptionButton*>(option));
}

void* QRadioButton_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QRadioButton*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QRadioButton_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QRadioButton*>(ptr)->QRadioButton::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QRadioButton_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QRadioButton_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

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_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QRadioButton*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QRadioButton_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QRadioButton*>(ptr)->QRadioButton::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QRadioButton_DestroyQRadioButton(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->~QRadioButton();
}

void QRadioButton_SetChecked(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}

void QRadioButton_SetCheckedDefault(void* ptr, char vbo)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::setChecked(vbo != 0);
}

void QRadioButton_SetIconSize(void* ptr, void* size)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setIconSize", Q_ARG(QSize, *static_cast<QSize*>(size)));
}

void QRadioButton_SetIconSizeDefault(void* ptr, void* size)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::setIconSize(*static_cast<QSize*>(size));
}

void QRadioButton_Toggle(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "toggle");
}

void QRadioButton_ToggleDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::toggle();
}

void QRadioButton_AnimateClick(void* ptr, int msec)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "animateClick", Q_ARG(int, msec));
}

void QRadioButton_AnimateClickDefault(void* ptr, int msec)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::animateClick(msec);
}

void QRadioButton_ChangeEvent(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QRadioButton_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::changeEvent(static_cast<QEvent*>(e));
}

void QRadioButton_CheckStateSet(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->checkStateSet();
}

void QRadioButton_CheckStateSetDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::checkStateSet();
}

void QRadioButton_Click(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "click");
}

void QRadioButton_ClickDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::click();
}

void QRadioButton_FocusInEvent(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(e));
}

void QRadioButton_FocusInEventDefault(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::focusInEvent(static_cast<QFocusEvent*>(e));
}

void QRadioButton_FocusOutEvent(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QRadioButton_FocusOutEventDefault(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QRadioButton_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QRadioButton_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QRadioButton_KeyReleaseEvent(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QRadioButton_KeyReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QRadioButton_MousePressEvent(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QRadioButton_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QRadioButton_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QRadioButton_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QRadioButton_NextCheckState(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->nextCheckState();
}

void QRadioButton_NextCheckStateDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::nextCheckState();
}

void QRadioButton_ActionEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QRadioButton_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::actionEvent(static_cast<QActionEvent*>(event));
}

void QRadioButton_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QRadioButton_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QRadioButton_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QRadioButton_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QRadioButton_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QRadioButton_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QRadioButton_DropEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QRadioButton_DropEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::dropEvent(static_cast<QDropEvent*>(event));
}

void QRadioButton_EnterEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QRadioButton_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::enterEvent(static_cast<QEvent*>(event));
}

void QRadioButton_HideEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QRadioButton_HideEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::hideEvent(static_cast<QHideEvent*>(event));
}

void QRadioButton_LeaveEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QRadioButton_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::leaveEvent(static_cast<QEvent*>(event));
}

void QRadioButton_MoveEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QRadioButton_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::moveEvent(static_cast<QMoveEvent*>(event));
}

void QRadioButton_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QRadioButton_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::setEnabled(vbo != 0);
}

void QRadioButton_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QRadioButton_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::setStyleSheet(QString(styleSheet));
}

void QRadioButton_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QRadioButton_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::setVisible(visible != 0);
}

void QRadioButton_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QRadioButton_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::setWindowModified(vbo != 0);
}

void QRadioButton_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QRadioButton_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::setWindowTitle(QString(vqs));
}

void QRadioButton_ShowEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QRadioButton_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::showEvent(static_cast<QShowEvent*>(event));
}

char QRadioButton_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QRadioButton_CloseDefault(void* ptr)
{
	return static_cast<QRadioButton*>(ptr)->QRadioButton::close();
}

void QRadioButton_CloseEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QRadioButton_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::closeEvent(static_cast<QCloseEvent*>(event));
}

void QRadioButton_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QRadioButton_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QRadioButton_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QRadioButton*>(ptr)->focusNextPrevChild(next != 0);
}

char QRadioButton_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QRadioButton*>(ptr)->QRadioButton::focusNextPrevChild(next != 0);
}

char QRadioButton_HasHeightForWidth(void* ptr)
{
	return static_cast<QRadioButton*>(ptr)->hasHeightForWidth();
}

char QRadioButton_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QRadioButton*>(ptr)->QRadioButton::hasHeightForWidth();
}

int QRadioButton_HeightForWidth(void* ptr, int w)
{
	return static_cast<QRadioButton*>(ptr)->heightForWidth(w);
}

int QRadioButton_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QRadioButton*>(ptr)->QRadioButton::heightForWidth(w);
}

void QRadioButton_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "hide");
}

void QRadioButton_HideDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::hide();
}

void QRadioButton_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QRadioButton_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QRadioButton_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QRadioButton*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QRadioButton_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QRadioButton*>(ptr)->QRadioButton::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QRadioButton_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "lower");
}

void QRadioButton_LowerDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::lower();
}

void QRadioButton_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QRadioButton_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QRadioButton_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QRadioButton*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QRadioButton_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QRadioButton*>(ptr)->QRadioButton::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QRadioButton_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "raise");
}

void QRadioButton_RaiseDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::raise();
}

void QRadioButton_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "repaint");
}

void QRadioButton_RepaintDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::repaint();
}

void QRadioButton_ResizeEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QRadioButton_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QRadioButton_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QRadioButton_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::setDisabled(disable != 0);
}

void QRadioButton_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setFocus");
}

void QRadioButton_SetFocus2Default(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::setFocus();
}

void QRadioButton_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QRadioButton_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::setHidden(hidden != 0);
}

void QRadioButton_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "show");
}

void QRadioButton_ShowDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::show();
}

void QRadioButton_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "showFullScreen");
}

void QRadioButton_ShowFullScreenDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::showFullScreen();
}

void QRadioButton_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "showMaximized");
}

void QRadioButton_ShowMaximizedDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::showMaximized();
}

void QRadioButton_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "showMinimized");
}

void QRadioButton_ShowMinimizedDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::showMinimized();
}

void QRadioButton_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "showNormal");
}

void QRadioButton_ShowNormalDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::showNormal();
}

void QRadioButton_TabletEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QRadioButton_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QRadioButton_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "update");
}

void QRadioButton_UpdateDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::update();
}

void QRadioButton_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "updateMicroFocus");
}

void QRadioButton_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::updateMicroFocus();
}

void QRadioButton_WheelEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QRadioButton_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QRadioButton_ChildEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QRadioButton_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::childEvent(static_cast<QChildEvent*>(event));
}

void QRadioButton_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QRadioButton*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QRadioButton_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QRadioButton_CustomEvent(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QRadioButton_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::customEvent(static_cast<QEvent*>(event));
}

void QRadioButton_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "deleteLater");
}

void QRadioButton_DeleteLaterDefault(void* ptr)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::deleteLater();
}

void QRadioButton_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QRadioButton*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QRadioButton_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QRadioButton*>(ptr)->QRadioButton::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QRadioButton_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QRadioButton*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QRadioButton_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QRadioButton*>(ptr)->QRadioButton::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QRadioButton_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QRadioButton*>(ptr)->metaObject());
}

void* QRadioButton_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QRadioButton*>(ptr)->QRadioButton::metaObject());
}

class MyQRubberBand: public QRubberBand
{
public:
	MyQRubberBand(Shape s, QWidget *p) : QRubberBand(s, p) {};
	void changeEvent(QEvent * e) { callbackQRubberBand_ChangeEvent(this, e); };
	void moveEvent(QMoveEvent * vqm) { callbackQRubberBand_MoveEvent(this, vqm); };
	void paintEvent(QPaintEvent * vqp) { callbackQRubberBand_PaintEvent(this, vqp); };
	void resizeEvent(QResizeEvent * vqr) { callbackQRubberBand_ResizeEvent(this, vqr); };
	void showEvent(QShowEvent * e) { callbackQRubberBand_ShowEvent(this, e); };
	void actionEvent(QActionEvent * event) { callbackQRubberBand_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQRubberBand_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQRubberBand_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQRubberBand_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQRubberBand_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQRubberBand_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQRubberBand_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQRubberBand_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQRubberBand_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQRubberBand_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQRubberBand_MinimumSizeHint(const_cast<MyQRubberBand*>(this))); };
	void setEnabled(bool vbo) { callbackQRubberBand_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQRubberBand_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQRubberBand_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQRubberBand_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQRubberBand_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQRubberBand_SizeHint(const_cast<MyQRubberBand*>(this))); };
	bool close() { return callbackQRubberBand_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQRubberBand_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQRubberBand_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQRubberBand_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQRubberBand_HasHeightForWidth(const_cast<MyQRubberBand*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQRubberBand_HeightForWidth(const_cast<MyQRubberBand*>(this), w); };
	void hide() { callbackQRubberBand_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQRubberBand_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQRubberBand_InputMethodQuery(const_cast<MyQRubberBand*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQRubberBand_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQRubberBand_KeyReleaseEvent(this, event); };
	void lower() { callbackQRubberBand_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQRubberBand_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQRubberBand_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQRubberBand_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQRubberBand_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQRubberBand_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQRubberBand_Raise(this); };
	void repaint() { callbackQRubberBand_Repaint(this); };
	void setDisabled(bool disable) { callbackQRubberBand_SetDisabled(this, disable); };
	void setFocus() { callbackQRubberBand_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQRubberBand_SetHidden(this, hidden); };
	void show() { callbackQRubberBand_Show(this); };
	void showFullScreen() { callbackQRubberBand_ShowFullScreen(this); };
	void showMaximized() { callbackQRubberBand_ShowMaximized(this); };
	void showMinimized() { callbackQRubberBand_ShowMinimized(this); };
	void showNormal() { callbackQRubberBand_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQRubberBand_TabletEvent(this, event); };
	void update() { callbackQRubberBand_Update(this); };
	void updateMicroFocus() { callbackQRubberBand_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQRubberBand_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQRubberBand_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQRubberBand_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQRubberBand_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQRubberBand_CustomEvent(this, event); };
	void deleteLater() { callbackQRubberBand_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQRubberBand_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQRubberBand_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQRubberBand_MetaObject(const_cast<MyQRubberBand*>(this))); };
};

void QRubberBand_SetGeometry(void* ptr, void* rect)
{
	static_cast<QRubberBand*>(ptr)->setGeometry(*static_cast<QRect*>(rect));
}

void* QRubberBand_NewQRubberBand(long long s, void* p)
{
	return new MyQRubberBand(static_cast<QRubberBand::Shape>(s), static_cast<QWidget*>(p));
}

void QRubberBand_ChangeEvent(void* ptr, void* e)
{
	static_cast<QRubberBand*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QRubberBand_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::changeEvent(static_cast<QEvent*>(e));
}

char QRubberBand_Event(void* ptr, void* e)
{
	return static_cast<QRubberBand*>(ptr)->event(static_cast<QEvent*>(e));
}

void QRubberBand_InitStyleOption(void* ptr, void* option)
{
	static_cast<QRubberBand*>(ptr)->initStyleOption(static_cast<QStyleOptionRubberBand*>(option));
}

void QRubberBand_Move2(void* ptr, void* p)
{
	static_cast<QRubberBand*>(ptr)->move(*static_cast<QPoint*>(p));
}

void QRubberBand_Move(void* ptr, int x, int y)
{
	static_cast<QRubberBand*>(ptr)->move(x, y);
}

void QRubberBand_MoveEvent(void* ptr, void* vqm)
{
	static_cast<QRubberBand*>(ptr)->moveEvent(static_cast<QMoveEvent*>(vqm));
}

void QRubberBand_MoveEventDefault(void* ptr, void* vqm)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::moveEvent(static_cast<QMoveEvent*>(vqm));
}

void QRubberBand_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QRubberBand*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QRubberBand_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QRubberBand_Resize2(void* ptr, void* size)
{
	static_cast<QRubberBand*>(ptr)->resize(*static_cast<QSize*>(size));
}

void QRubberBand_Resize(void* ptr, int width, int height)
{
	static_cast<QRubberBand*>(ptr)->resize(width, height);
}

void QRubberBand_ResizeEvent(void* ptr, void* vqr)
{
	static_cast<QRubberBand*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QRubberBand_ResizeEventDefault(void* ptr, void* vqr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QRubberBand_SetGeometry2(void* ptr, int x, int y, int width, int height)
{
	static_cast<QRubberBand*>(ptr)->setGeometry(x, y, width, height);
}

long long QRubberBand_Shape(void* ptr)
{
	return static_cast<QRubberBand*>(ptr)->shape();
}

void QRubberBand_ShowEvent(void* ptr, void* e)
{
	static_cast<QRubberBand*>(ptr)->showEvent(static_cast<QShowEvent*>(e));
}

void QRubberBand_ShowEventDefault(void* ptr, void* e)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::showEvent(static_cast<QShowEvent*>(e));
}

void QRubberBand_DestroyQRubberBand(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->~QRubberBand();
}

void QRubberBand_ActionEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QRubberBand_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::actionEvent(static_cast<QActionEvent*>(event));
}

void QRubberBand_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QRubberBand_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QRubberBand_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QRubberBand_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QRubberBand_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QRubberBand_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QRubberBand_DropEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QRubberBand_DropEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::dropEvent(static_cast<QDropEvent*>(event));
}

void QRubberBand_EnterEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QRubberBand_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::enterEvent(static_cast<QEvent*>(event));
}

void QRubberBand_FocusInEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QRubberBand_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QRubberBand_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QRubberBand_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QRubberBand_HideEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QRubberBand_HideEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::hideEvent(static_cast<QHideEvent*>(event));
}

void QRubberBand_LeaveEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QRubberBand_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::leaveEvent(static_cast<QEvent*>(event));
}

void* QRubberBand_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QRubberBand*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QRubberBand_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QRubberBand*>(ptr)->QRubberBand::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QRubberBand_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QRubberBand_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::setEnabled(vbo != 0);
}

void QRubberBand_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QRubberBand_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::setStyleSheet(QString(styleSheet));
}

void QRubberBand_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QRubberBand_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::setVisible(visible != 0);
}

void QRubberBand_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QRubberBand_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::setWindowModified(vbo != 0);
}

void QRubberBand_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QRubberBand_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::setWindowTitle(QString(vqs));
}

void* QRubberBand_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QRubberBand*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QRubberBand_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QRubberBand*>(ptr)->QRubberBand::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

char QRubberBand_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QRubberBand_CloseDefault(void* ptr)
{
	return static_cast<QRubberBand*>(ptr)->QRubberBand::close();
}

void QRubberBand_CloseEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QRubberBand_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::closeEvent(static_cast<QCloseEvent*>(event));
}

void QRubberBand_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QRubberBand_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QRubberBand_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QRubberBand*>(ptr)->focusNextPrevChild(next != 0);
}

char QRubberBand_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QRubberBand*>(ptr)->QRubberBand::focusNextPrevChild(next != 0);
}

char QRubberBand_HasHeightForWidth(void* ptr)
{
	return static_cast<QRubberBand*>(ptr)->hasHeightForWidth();
}

char QRubberBand_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QRubberBand*>(ptr)->QRubberBand::hasHeightForWidth();
}

int QRubberBand_HeightForWidth(void* ptr, int w)
{
	return static_cast<QRubberBand*>(ptr)->heightForWidth(w);
}

int QRubberBand_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QRubberBand*>(ptr)->QRubberBand::heightForWidth(w);
}

void QRubberBand_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "hide");
}

void QRubberBand_HideDefault(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::hide();
}

void QRubberBand_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QRubberBand_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QRubberBand_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QRubberBand*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QRubberBand_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QRubberBand*>(ptr)->QRubberBand::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QRubberBand_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QRubberBand_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QRubberBand_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QRubberBand_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QRubberBand_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "lower");
}

void QRubberBand_LowerDefault(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::lower();
}

void QRubberBand_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QRubberBand_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QRubberBand_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QRubberBand_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QRubberBand_MousePressEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QRubberBand_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QRubberBand_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QRubberBand_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QRubberBand_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QRubberBand*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QRubberBand_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QRubberBand*>(ptr)->QRubberBand::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QRubberBand_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "raise");
}

void QRubberBand_RaiseDefault(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::raise();
}

void QRubberBand_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "repaint");
}

void QRubberBand_RepaintDefault(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::repaint();
}

void QRubberBand_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QRubberBand_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::setDisabled(disable != 0);
}

void QRubberBand_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "setFocus");
}

void QRubberBand_SetFocus2Default(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::setFocus();
}

void QRubberBand_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QRubberBand_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::setHidden(hidden != 0);
}

void QRubberBand_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "show");
}

void QRubberBand_ShowDefault(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::show();
}

void QRubberBand_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "showFullScreen");
}

void QRubberBand_ShowFullScreenDefault(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::showFullScreen();
}

void QRubberBand_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "showMaximized");
}

void QRubberBand_ShowMaximizedDefault(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::showMaximized();
}

void QRubberBand_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "showMinimized");
}

void QRubberBand_ShowMinimizedDefault(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::showMinimized();
}

void QRubberBand_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "showNormal");
}

void QRubberBand_ShowNormalDefault(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::showNormal();
}

void QRubberBand_TabletEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QRubberBand_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QRubberBand_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "update");
}

void QRubberBand_UpdateDefault(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::update();
}

void QRubberBand_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "updateMicroFocus");
}

void QRubberBand_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::updateMicroFocus();
}

void QRubberBand_WheelEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QRubberBand_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QRubberBand_TimerEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QRubberBand_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::timerEvent(static_cast<QTimerEvent*>(event));
}

void QRubberBand_ChildEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QRubberBand_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::childEvent(static_cast<QChildEvent*>(event));
}

void QRubberBand_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QRubberBand*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QRubberBand_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QRubberBand_CustomEvent(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QRubberBand_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::customEvent(static_cast<QEvent*>(event));
}

void QRubberBand_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "deleteLater");
}

void QRubberBand_DeleteLaterDefault(void* ptr)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::deleteLater();
}

void QRubberBand_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QRubberBand*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QRubberBand_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QRubberBand*>(ptr)->QRubberBand::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QRubberBand_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QRubberBand*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QRubberBand_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QRubberBand*>(ptr)->QRubberBand::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QRubberBand_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QRubberBand*>(ptr)->metaObject());
}

void* QRubberBand_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QRubberBand*>(ptr)->QRubberBand::metaObject());
}

class MyQScrollArea: public QScrollArea
{
public:
	MyQScrollArea(QWidget *parent) : QScrollArea(parent) {};
	bool focusNextPrevChild(bool next) { return callbackQScrollArea_FocusNextPrevChild(this, next) != 0; };
	void resizeEvent(QResizeEvent * vqr) { callbackQScrollArea_ResizeEvent(this, vqr); };
	void scrollContentsBy(int dx, int dy) { callbackQScrollArea_ScrollContentsBy(this, dx, dy); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQScrollArea_SizeHint(const_cast<MyQScrollArea*>(this))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQScrollArea_ViewportSizeHint(const_cast<MyQScrollArea*>(this))); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQScrollArea_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQScrollArea_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQScrollArea_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQScrollArea_DropEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQScrollArea_PaintEvent(this, event); };
	bool viewportEvent(QEvent * event) { return callbackQScrollArea_ViewportEvent(this, event) != 0; };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQScrollArea_ContextMenuEvent(this, e); };
	void keyPressEvent(QKeyEvent * e) { callbackQScrollArea_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQScrollArea_MinimumSizeHint(const_cast<MyQScrollArea*>(this))); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQScrollArea_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQScrollArea_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQScrollArea_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQScrollArea_MouseReleaseEvent(this, e); };
	void setupViewport(QWidget * viewport) { callbackQScrollArea_SetupViewport(this, viewport); };
	void wheelEvent(QWheelEvent * e) { callbackQScrollArea_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQScrollArea_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQScrollArea_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQScrollArea_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQScrollArea_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQScrollArea_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQScrollArea_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQScrollArea_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQScrollArea_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQScrollArea_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQScrollArea_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQScrollArea_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQScrollArea_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQScrollArea_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQScrollArea_ShowEvent(this, event); };
	bool close() { return callbackQScrollArea_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQScrollArea_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQScrollArea_HasHeightForWidth(const_cast<MyQScrollArea*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQScrollArea_HeightForWidth(const_cast<MyQScrollArea*>(this), w); };
	void hide() { callbackQScrollArea_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQScrollArea_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQScrollArea_InputMethodQuery(const_cast<MyQScrollArea*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQScrollArea_KeyReleaseEvent(this, event); };
	void lower() { callbackQScrollArea_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQScrollArea_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQScrollArea_Raise(this); };
	void repaint() { callbackQScrollArea_Repaint(this); };
	void setDisabled(bool disable) { callbackQScrollArea_SetDisabled(this, disable); };
	void setFocus() { callbackQScrollArea_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQScrollArea_SetHidden(this, hidden); };
	void show() { callbackQScrollArea_Show(this); };
	void showFullScreen() { callbackQScrollArea_ShowFullScreen(this); };
	void showMaximized() { callbackQScrollArea_ShowMaximized(this); };
	void showMinimized() { callbackQScrollArea_ShowMinimized(this); };
	void showNormal() { callbackQScrollArea_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQScrollArea_TabletEvent(this, event); };
	void update() { callbackQScrollArea_Update(this); };
	void updateMicroFocus() { callbackQScrollArea_UpdateMicroFocus(this); };
	void timerEvent(QTimerEvent * event) { callbackQScrollArea_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQScrollArea_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQScrollArea_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQScrollArea_CustomEvent(this, event); };
	void deleteLater() { callbackQScrollArea_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQScrollArea_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQScrollArea_MetaObject(const_cast<MyQScrollArea*>(this))); };
};

long long QScrollArea_Alignment(void* ptr)
{
	return static_cast<QScrollArea*>(ptr)->alignment();
}

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);
}

char QScrollArea_WidgetResizable(void* ptr)
{
	return static_cast<QScrollArea*>(ptr)->widgetResizable();
}

void* QScrollArea_NewQScrollArea(void* parent)
{
	return new MyQScrollArea(static_cast<QWidget*>(parent));
}

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);
}

char QScrollArea_Event(void* ptr, void* e)
{
	return static_cast<QScrollArea*>(ptr)->event(static_cast<QEvent*>(e));
}

char QScrollArea_EventFilter(void* ptr, void* o, void* e)
{
	return static_cast<QScrollArea*>(ptr)->eventFilter(static_cast<QObject*>(o), static_cast<QEvent*>(e));
}

char QScrollArea_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QScrollArea*>(ptr)->focusNextPrevChild(next != 0);
}

char QScrollArea_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QScrollArea*>(ptr)->QScrollArea::focusNextPrevChild(next != 0);
}

void QScrollArea_ResizeEvent(void* ptr, void* vqr)
{
	static_cast<QScrollArea*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QScrollArea_ResizeEventDefault(void* ptr, void* vqr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QScrollArea_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QScrollArea*>(ptr)->scrollContentsBy(dx, dy);
}

void QScrollArea_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::scrollContentsBy(dx, dy);
}

void* QScrollArea_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScrollArea*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QScrollArea_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScrollArea*>(ptr)->QScrollArea::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QScrollArea_TakeWidget(void* ptr)
{
	return static_cast<QScrollArea*>(ptr)->takeWidget();
}

void* QScrollArea_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScrollArea*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QScrollArea_ViewportSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScrollArea*>(ptr)->QScrollArea::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QScrollArea_Widget(void* ptr)
{
	return static_cast<QScrollArea*>(ptr)->widget();
}

void QScrollArea_DestroyQScrollArea(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->~QScrollArea();
}

void QScrollArea_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QScrollArea_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QScrollArea_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QScrollArea_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QScrollArea_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QScrollArea_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QScrollArea_DropEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QScrollArea_DropEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::dropEvent(static_cast<QDropEvent*>(event));
}

void QScrollArea_PaintEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QScrollArea_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::paintEvent(static_cast<QPaintEvent*>(event));
}

char QScrollArea_ViewportEvent(void* ptr, void* event)
{
	return static_cast<QScrollArea*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}

char QScrollArea_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QScrollArea*>(ptr)->QScrollArea::viewportEvent(static_cast<QEvent*>(event));
}

void QScrollArea_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QScrollArea_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QScrollArea_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QScrollArea_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void* QScrollArea_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScrollArea*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QScrollArea_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScrollArea*>(ptr)->QScrollArea::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QScrollArea_MouseDoubleClickEvent(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QScrollArea_MouseDoubleClickEventDefault(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QScrollArea_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QScrollArea_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QScrollArea_MousePressEvent(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QScrollArea_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QScrollArea_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QScrollArea_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QScrollArea_SetupViewport(void* ptr, void* viewport)
{
	static_cast<QScrollArea*>(ptr)->setupViewport(static_cast<QWidget*>(viewport));
}

void QScrollArea_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::setupViewport(static_cast<QWidget*>(viewport));
}

void QScrollArea_WheelEvent(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QScrollArea_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QScrollArea_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QScrollArea*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QScrollArea_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::changeEvent(static_cast<QEvent*>(ev));
}

void QScrollArea_ActionEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QScrollArea_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::actionEvent(static_cast<QActionEvent*>(event));
}

void QScrollArea_EnterEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QScrollArea_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::enterEvent(static_cast<QEvent*>(event));
}

void QScrollArea_FocusInEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QScrollArea_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QScrollArea_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QScrollArea_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QScrollArea_HideEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QScrollArea_HideEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::hideEvent(static_cast<QHideEvent*>(event));
}

void QScrollArea_LeaveEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QScrollArea_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::leaveEvent(static_cast<QEvent*>(event));
}

void QScrollArea_MoveEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QScrollArea_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::moveEvent(static_cast<QMoveEvent*>(event));
}

void QScrollArea_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QScrollArea_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::setEnabled(vbo != 0);
}

void QScrollArea_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QScrollArea_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::setStyleSheet(QString(styleSheet));
}

void QScrollArea_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QScrollArea_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::setVisible(visible != 0);
}

void QScrollArea_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QScrollArea_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::setWindowModified(vbo != 0);
}

void QScrollArea_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QScrollArea_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::setWindowTitle(QString(vqs));
}

void QScrollArea_ShowEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QScrollArea_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::showEvent(static_cast<QShowEvent*>(event));
}

char QScrollArea_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QScrollArea_CloseDefault(void* ptr)
{
	return static_cast<QScrollArea*>(ptr)->QScrollArea::close();
}

void QScrollArea_CloseEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QScrollArea_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::closeEvent(static_cast<QCloseEvent*>(event));
}

char QScrollArea_HasHeightForWidth(void* ptr)
{
	return static_cast<QScrollArea*>(ptr)->hasHeightForWidth();
}

char QScrollArea_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QScrollArea*>(ptr)->QScrollArea::hasHeightForWidth();
}

int QScrollArea_HeightForWidth(void* ptr, int w)
{
	return static_cast<QScrollArea*>(ptr)->heightForWidth(w);
}

int QScrollArea_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QScrollArea*>(ptr)->QScrollArea::heightForWidth(w);
}

void QScrollArea_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "hide");
}

void QScrollArea_HideDefault(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::hide();
}

void QScrollArea_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QScrollArea_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QScrollArea_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QScrollArea*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QScrollArea_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QScrollArea*>(ptr)->QScrollArea::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QScrollArea_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QScrollArea_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QScrollArea_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "lower");
}

void QScrollArea_LowerDefault(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::lower();
}

char QScrollArea_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QScrollArea*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QScrollArea_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QScrollArea*>(ptr)->QScrollArea::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QScrollArea_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "raise");
}

void QScrollArea_RaiseDefault(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::raise();
}

void QScrollArea_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "repaint");
}

void QScrollArea_RepaintDefault(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::repaint();
}

void QScrollArea_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QScrollArea_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::setDisabled(disable != 0);
}

void QScrollArea_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "setFocus");
}

void QScrollArea_SetFocus2Default(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::setFocus();
}

void QScrollArea_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QScrollArea_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::setHidden(hidden != 0);
}

void QScrollArea_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "show");
}

void QScrollArea_ShowDefault(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::show();
}

void QScrollArea_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "showFullScreen");
}

void QScrollArea_ShowFullScreenDefault(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::showFullScreen();
}

void QScrollArea_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "showMaximized");
}

void QScrollArea_ShowMaximizedDefault(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::showMaximized();
}

void QScrollArea_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "showMinimized");
}

void QScrollArea_ShowMinimizedDefault(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::showMinimized();
}

void QScrollArea_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "showNormal");
}

void QScrollArea_ShowNormalDefault(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::showNormal();
}

void QScrollArea_TabletEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QScrollArea_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QScrollArea_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "update");
}

void QScrollArea_UpdateDefault(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::update();
}

void QScrollArea_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "updateMicroFocus");
}

void QScrollArea_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::updateMicroFocus();
}

void QScrollArea_TimerEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QScrollArea_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::timerEvent(static_cast<QTimerEvent*>(event));
}

void QScrollArea_ChildEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QScrollArea_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::childEvent(static_cast<QChildEvent*>(event));
}

void QScrollArea_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QScrollArea*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QScrollArea_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QScrollArea_CustomEvent(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QScrollArea_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::customEvent(static_cast<QEvent*>(event));
}

void QScrollArea_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "deleteLater");
}

void QScrollArea_DeleteLaterDefault(void* ptr)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::deleteLater();
}

void QScrollArea_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QScrollArea*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QScrollArea_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QScrollArea*>(ptr)->QScrollArea::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void* QScrollArea_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QScrollArea*>(ptr)->metaObject());
}

void* QScrollArea_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QScrollArea*>(ptr)->QScrollArea::metaObject());
}

class MyQScrollBar: public QScrollBar
{
public:
	MyQScrollBar(QWidget *parent) : QScrollBar(parent) {};
	MyQScrollBar(Qt::Orientation orientation, QWidget *parent) : QScrollBar(orientation, parent) {};
	void contextMenuEvent(QContextMenuEvent * event) { callbackQScrollBar_ContextMenuEvent(this, event); };
	void hideEvent(QHideEvent * vqh) { callbackQScrollBar_HideEvent(this, vqh); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQScrollBar_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQScrollBar_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQScrollBar_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * vqp) { callbackQScrollBar_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQScrollBar_SizeHint(const_cast<MyQScrollBar*>(this))); };
	void sliderChange(QAbstractSlider::SliderChange change) { callbackQScrollBar_SliderChange(this, change); };
	void wheelEvent(QWheelEvent * event) { callbackQScrollBar_WheelEvent(this, event); };
	void setOrientation(Qt::Orientation vqt) { callbackQScrollBar_SetOrientation(this, vqt); };
	void setValue(int vin) { callbackQScrollBar_SetValue(this, vin); };
	void changeEvent(QEvent * ev) { callbackQScrollBar_ChangeEvent(this, ev); };
	void keyPressEvent(QKeyEvent * ev) { callbackQScrollBar_KeyPressEvent(this, ev); };
	void setRange(int min, int max) { callbackQScrollBar_SetRange(this, min, max); };
	void actionEvent(QActionEvent * event) { callbackQScrollBar_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQScrollBar_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQScrollBar_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQScrollBar_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQScrollBar_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQScrollBar_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQScrollBar_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQScrollBar_FocusOutEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQScrollBar_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQScrollBar_MinimumSizeHint(const_cast<MyQScrollBar*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQScrollBar_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQScrollBar_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQScrollBar_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQScrollBar_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQScrollBar_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQScrollBar_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQScrollBar_ShowEvent(this, event); };
	bool close() { return callbackQScrollBar_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQScrollBar_CloseEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQScrollBar_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQScrollBar_HasHeightForWidth(const_cast<MyQScrollBar*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQScrollBar_HeightForWidth(const_cast<MyQScrollBar*>(this), w); };
	void hide() { callbackQScrollBar_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQScrollBar_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQScrollBar_InputMethodQuery(const_cast<MyQScrollBar*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQScrollBar_KeyReleaseEvent(this, event); };
	void lower() { callbackQScrollBar_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQScrollBar_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQScrollBar_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQScrollBar_Raise(this); };
	void repaint() { callbackQScrollBar_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQScrollBar_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQScrollBar_SetDisabled(this, disable); };
	void setFocus() { callbackQScrollBar_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQScrollBar_SetHidden(this, hidden); };
	void show() { callbackQScrollBar_Show(this); };
	void showFullScreen() { callbackQScrollBar_ShowFullScreen(this); };
	void showMaximized() { callbackQScrollBar_ShowMaximized(this); };
	void showMinimized() { callbackQScrollBar_ShowMinimized(this); };
	void showNormal() { callbackQScrollBar_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQScrollBar_TabletEvent(this, event); };
	void update() { callbackQScrollBar_Update(this); };
	void updateMicroFocus() { callbackQScrollBar_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQScrollBar_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQScrollBar_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQScrollBar_CustomEvent(this, event); };
	void deleteLater() { callbackQScrollBar_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQScrollBar_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQScrollBar_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQScrollBar_MetaObject(const_cast<MyQScrollBar*>(this))); };
};

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_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QScrollBar_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QScrollBar_Event(void* ptr, void* event)
{
	return static_cast<QScrollBar*>(ptr)->event(static_cast<QEvent*>(event));
}

void QScrollBar_HideEvent(void* ptr, void* vqh)
{
	static_cast<QScrollBar*>(ptr)->hideEvent(static_cast<QHideEvent*>(vqh));
}

void QScrollBar_HideEventDefault(void* ptr, void* vqh)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::hideEvent(static_cast<QHideEvent*>(vqh));
}

void QScrollBar_InitStyleOption(void* ptr, void* option)
{
	static_cast<QScrollBar*>(ptr)->initStyleOption(static_cast<QStyleOptionSlider*>(option));
}

void QScrollBar_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QScrollBar*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QScrollBar_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QScrollBar_MousePressEvent(void* ptr, void* e)
{
	static_cast<QScrollBar*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QScrollBar_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QScrollBar_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QScrollBar*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QScrollBar_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QScrollBar_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QScrollBar*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QScrollBar_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void* QScrollBar_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScrollBar*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QScrollBar_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScrollBar*>(ptr)->QScrollBar::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QScrollBar_SliderChange(void* ptr, long long change)
{
	static_cast<QScrollBar*>(ptr)->sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
}

void QScrollBar_SliderChangeDefault(void* ptr, long long change)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
}

void QScrollBar_WheelEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QScrollBar_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QScrollBar_DestroyQScrollBar(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->~QScrollBar();
}

void QScrollBar_SetOrientation(void* ptr, long long vqt)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setOrientation", Q_ARG(Qt::Orientation, static_cast<Qt::Orientation>(vqt)));
}

void QScrollBar_SetOrientationDefault(void* ptr, long long vqt)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::setOrientation(static_cast<Qt::Orientation>(vqt));
}

void QScrollBar_SetValue(void* ptr, int vin)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setValue", Q_ARG(int, vin));
}

void QScrollBar_SetValueDefault(void* ptr, int vin)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::setValue(vin);
}

void QScrollBar_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QScrollBar*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QScrollBar_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::changeEvent(static_cast<QEvent*>(ev));
}

void QScrollBar_KeyPressEvent(void* ptr, void* ev)
{
	static_cast<QScrollBar*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(ev));
}

void QScrollBar_KeyPressEventDefault(void* ptr, void* ev)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::keyPressEvent(static_cast<QKeyEvent*>(ev));
}

void QScrollBar_SetRange(void* ptr, int min, int max)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setRange", Q_ARG(int, min), Q_ARG(int, max));
}

void QScrollBar_SetRangeDefault(void* ptr, int min, int max)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::setRange(min, max);
}

void QScrollBar_ActionEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QScrollBar_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::actionEvent(static_cast<QActionEvent*>(event));
}

void QScrollBar_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QScrollBar_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QScrollBar_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QScrollBar_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QScrollBar_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QScrollBar_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QScrollBar_DropEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QScrollBar_DropEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::dropEvent(static_cast<QDropEvent*>(event));
}

void QScrollBar_EnterEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QScrollBar_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::enterEvent(static_cast<QEvent*>(event));
}

void QScrollBar_FocusInEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QScrollBar_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QScrollBar_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QScrollBar_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QScrollBar_LeaveEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QScrollBar_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::leaveEvent(static_cast<QEvent*>(event));
}

void* QScrollBar_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScrollBar*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QScrollBar_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScrollBar*>(ptr)->QScrollBar::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QScrollBar_MoveEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QScrollBar_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::moveEvent(static_cast<QMoveEvent*>(event));
}

void QScrollBar_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QScrollBar_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::setEnabled(vbo != 0);
}

void QScrollBar_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QScrollBar_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::setStyleSheet(QString(styleSheet));
}

void QScrollBar_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QScrollBar_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::setVisible(visible != 0);
}

void QScrollBar_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QScrollBar_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::setWindowModified(vbo != 0);
}

void QScrollBar_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QScrollBar_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::setWindowTitle(QString(vqs));
}

void QScrollBar_ShowEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QScrollBar_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::showEvent(static_cast<QShowEvent*>(event));
}

char QScrollBar_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QScrollBar_CloseDefault(void* ptr)
{
	return static_cast<QScrollBar*>(ptr)->QScrollBar::close();
}

void QScrollBar_CloseEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QScrollBar_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::closeEvent(static_cast<QCloseEvent*>(event));
}

char QScrollBar_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QScrollBar*>(ptr)->focusNextPrevChild(next != 0);
}

char QScrollBar_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QScrollBar*>(ptr)->QScrollBar::focusNextPrevChild(next != 0);
}

char QScrollBar_HasHeightForWidth(void* ptr)
{
	return static_cast<QScrollBar*>(ptr)->hasHeightForWidth();
}

char QScrollBar_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QScrollBar*>(ptr)->QScrollBar::hasHeightForWidth();
}

int QScrollBar_HeightForWidth(void* ptr, int w)
{
	return static_cast<QScrollBar*>(ptr)->heightForWidth(w);
}

int QScrollBar_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QScrollBar*>(ptr)->QScrollBar::heightForWidth(w);
}

void QScrollBar_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "hide");
}

void QScrollBar_HideDefault(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::hide();
}

void QScrollBar_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QScrollBar_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QScrollBar_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QScrollBar*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QScrollBar_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QScrollBar*>(ptr)->QScrollBar::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QScrollBar_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QScrollBar_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QScrollBar_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "lower");
}

void QScrollBar_LowerDefault(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::lower();
}

void QScrollBar_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QScrollBar_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QScrollBar_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QScrollBar*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QScrollBar_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QScrollBar*>(ptr)->QScrollBar::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QScrollBar_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "raise");
}

void QScrollBar_RaiseDefault(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::raise();
}

void QScrollBar_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "repaint");
}

void QScrollBar_RepaintDefault(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::repaint();
}

void QScrollBar_ResizeEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QScrollBar_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QScrollBar_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QScrollBar_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::setDisabled(disable != 0);
}

void QScrollBar_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setFocus");
}

void QScrollBar_SetFocus2Default(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::setFocus();
}

void QScrollBar_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QScrollBar_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::setHidden(hidden != 0);
}

void QScrollBar_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "show");
}

void QScrollBar_ShowDefault(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::show();
}

void QScrollBar_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "showFullScreen");
}

void QScrollBar_ShowFullScreenDefault(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::showFullScreen();
}

void QScrollBar_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "showMaximized");
}

void QScrollBar_ShowMaximizedDefault(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::showMaximized();
}

void QScrollBar_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "showMinimized");
}

void QScrollBar_ShowMinimizedDefault(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::showMinimized();
}

void QScrollBar_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "showNormal");
}

void QScrollBar_ShowNormalDefault(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::showNormal();
}

void QScrollBar_TabletEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QScrollBar_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QScrollBar_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "update");
}

void QScrollBar_UpdateDefault(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::update();
}

void QScrollBar_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "updateMicroFocus");
}

void QScrollBar_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::updateMicroFocus();
}

void QScrollBar_ChildEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QScrollBar_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::childEvent(static_cast<QChildEvent*>(event));
}

void QScrollBar_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QScrollBar*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QScrollBar_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QScrollBar_CustomEvent(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QScrollBar_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::customEvent(static_cast<QEvent*>(event));
}

void QScrollBar_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "deleteLater");
}

void QScrollBar_DeleteLaterDefault(void* ptr)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::deleteLater();
}

void QScrollBar_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QScrollBar*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QScrollBar_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QScrollBar*>(ptr)->QScrollBar::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QScrollBar_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QScrollBar*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QScrollBar_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QScrollBar*>(ptr)->QScrollBar::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QScrollBar_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QScrollBar*>(ptr)->metaObject());
}

void* QScrollBar_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QScrollBar*>(ptr)->QScrollBar::metaObject());
}

class MyQScroller: public QScroller
{
public:
	void setScrollerProperties(const QScrollerProperties & prop) { callbackQScroller_SetScrollerProperties(this, const_cast<QScrollerProperties*>(&prop)); };
	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 Signal_StateChanged(QScroller::State newState) { callbackQScroller_StateChanged(this, newState); };
	void timerEvent(QTimerEvent * event) { callbackQScroller_TimerEvent(this, event); };
	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 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<MyQScroller*>(this))); };
};

void* QScroller_ScrollerProperties(void* ptr)
{
	return new QScrollerProperties(static_cast<QScroller*>(ptr)->scrollerProperties());
}

void QScroller_SetScrollerProperties(void* ptr, void* prop)
{
	QMetaObject::invokeMethod(static_cast<QScroller*>(ptr), "setScrollerProperties", Q_ARG(QScrollerProperties, *static_cast<QScrollerProperties*>(prop)));
}

long long QScroller_State(void* ptr)
{
	return static_cast<QScroller*>(ptr)->state();
}

void QScroller_EnsureVisible(void* ptr, void* rect, double xmargin, double ymargin)
{
	QMetaObject::invokeMethod(static_cast<QScroller*>(ptr), "ensureVisible", Q_ARG(QRectF, *static_cast<QRectF*>(rect)), Q_ARG(qreal, xmargin), Q_ARG(qreal, ymargin));
}

void QScroller_EnsureVisible2(void* ptr, void* rect, double xmargin, double ymargin, int scrollTime)
{
	QMetaObject::invokeMethod(static_cast<QScroller*>(ptr), "ensureVisible", Q_ARG(QRectF, *static_cast<QRectF*>(rect)), Q_ARG(qreal, xmargin), Q_ARG(qreal, ymargin), Q_ARG(int, 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)
{
	return QScroller::grabGesture(static_cast<QObject*>(target), static_cast<QScroller::ScrollerGestureType>(scrollGestureType));
}

long long QScroller_QScroller_GrabbedGesture(void* target)
{
	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)
{
	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_ScrollTo(void* ptr, void* pos)
{
	QMetaObject::invokeMethod(static_cast<QScroller*>(ptr), "scrollTo", Q_ARG(QPointF, *static_cast<QPointF*>(pos)));
}

void QScroller_ScrollTo2(void* ptr, void* pos, int scrollTime)
{
	QMetaObject::invokeMethod(static_cast<QScroller*>(ptr), "scrollTo", Q_ARG(QPointF, *static_cast<QPointF*>(pos)), Q_ARG(int, scrollTime));
}

void* QScroller_QScroller_Scroller(void* target)
{
	return QScroller::scroller(static_cast<QObject*>(target));
}

void* QScroller_QScroller_Scroller2(void* target)
{
	return const_cast<QScroller*>(QScroller::scroller(static_cast<QObject*>(target)));
}

void QScroller_ConnectScrollerPropertiesChanged(void* ptr)
{
	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));
}

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_SetSnapPositionsX2(void* ptr, double first, double interval)
{
	static_cast<QScroller*>(ptr)->setSnapPositionsX(first, interval);
}

void QScroller_SetSnapPositionsY2(void* ptr, double first, double interval)
{
	static_cast<QScroller*>(ptr)->setSnapPositionsY(first, interval);
}

void QScroller_ConnectStateChanged(void* ptr)
{
	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));
}

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)
{
	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_TimerEvent(void* ptr, void* event)
{
	static_cast<QScroller*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QScroller_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QScroller*>(ptr)->QScroller::timerEvent(static_cast<QTimerEvent*>(event));
}

void QScroller_ChildEvent(void* ptr, void* event)
{
	static_cast<QScroller*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QScroller_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QScroller*>(ptr)->QScroller::childEvent(static_cast<QChildEvent*>(event));
}

void QScroller_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QScroller*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QScroller_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QScroller*>(ptr)->QScroller::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QScroller_CustomEvent(void* ptr, void* event)
{
	static_cast<QScroller*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QScroller_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QScroller*>(ptr)->QScroller::customEvent(static_cast<QEvent*>(event));
}

void QScroller_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QScroller*>(ptr), "deleteLater");
}

void QScroller_DeleteLaterDefault(void* ptr)
{
	static_cast<QScroller*>(ptr)->QScroller::deleteLater();
}

void QScroller_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QScroller*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QScroller_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QScroller*>(ptr)->QScroller::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QScroller_Event(void* ptr, void* e)
{
	return static_cast<QScroller*>(ptr)->event(static_cast<QEvent*>(e));
}

char QScroller_EventDefault(void* ptr, void* e)
{
	return static_cast<QScroller*>(ptr)->QScroller::event(static_cast<QEvent*>(e));
}

char QScroller_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QScroller*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QScroller_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QScroller*>(ptr)->QScroller::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QScroller_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QScroller*>(ptr)->metaObject());
}

void* QScroller_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QScroller*>(ptr)->QScroller::metaObject());
}

class MyQScrollerProperties: public QScrollerProperties
{
public:
	MyQScrollerProperties() : QScrollerProperties() {};
	MyQScrollerProperties(const QScrollerProperties &sp) : QScrollerProperties(sp) {};
	 ~MyQScrollerProperties() { callbackQScrollerProperties_DestroyQScrollerProperties(this); };
};

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)
{

}

class MyQShortcut: public QShortcut
{
public:
	MyQShortcut(QWidget *parent) : QShortcut(parent) {};
	MyQShortcut(const QKeySequence &key, QWidget *parent, const char *member, const char *ambiguousMember, Qt::ShortcutContext context) : QShortcut(key, parent, member, ambiguousMember, context) {};
	void Signal_Activated() { callbackQShortcut_Activated(this); };
	void Signal_ActivatedAmbiguously() { callbackQShortcut_ActivatedAmbiguously(this); };
	void timerEvent(QTimerEvent * event) { callbackQShortcut_TimerEvent(this, event); };
	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 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<MyQShortcut*>(this))); };
};

char QShortcut_AutoRepeat(void* ptr)
{
	return static_cast<QShortcut*>(ptr)->autoRepeat();
}

long long QShortcut_Context(void* ptr)
{
	return static_cast<QShortcut*>(ptr)->context();
}

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_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, char* text)
{
	static_cast<QShortcut*>(ptr)->setWhatsThis(QString(text));
}

char* QShortcut_WhatsThis(void* ptr)
{
	return const_cast<char*>(static_cast<QShortcut*>(ptr)->whatsThis().toUtf8().prepend("WHITESPACE").constData()+10);
}

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)
{
	QObject::connect(static_cast<QShortcut*>(ptr), static_cast<void (QShortcut::*)()>(&QShortcut::activated), static_cast<MyQShortcut*>(ptr), static_cast<void (MyQShortcut::*)()>(&MyQShortcut::Signal_Activated));
}

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)
{
	QObject::connect(static_cast<QShortcut*>(ptr), static_cast<void (QShortcut::*)()>(&QShortcut::activatedAmbiguously), static_cast<MyQShortcut*>(ptr), static_cast<void (MyQShortcut::*)()>(&MyQShortcut::Signal_ActivatedAmbiguously));
}

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();
}

int QShortcut_Id(void* ptr)
{
	return static_cast<QShortcut*>(ptr)->id();
}

void* QShortcut_ParentWidget(void* ptr)
{
	return static_cast<QShortcut*>(ptr)->parentWidget();
}

void QShortcut_DestroyQShortcut(void* ptr)
{
	static_cast<QShortcut*>(ptr)->~QShortcut();
}

void QShortcut_TimerEvent(void* ptr, void* event)
{
	static_cast<QShortcut*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QShortcut_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QShortcut*>(ptr)->QShortcut::timerEvent(static_cast<QTimerEvent*>(event));
}

void QShortcut_ChildEvent(void* ptr, void* event)
{
	static_cast<QShortcut*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QShortcut_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QShortcut*>(ptr)->QShortcut::childEvent(static_cast<QChildEvent*>(event));
}

void QShortcut_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QShortcut*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QShortcut_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QShortcut*>(ptr)->QShortcut::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QShortcut_CustomEvent(void* ptr, void* event)
{
	static_cast<QShortcut*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QShortcut_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QShortcut*>(ptr)->QShortcut::customEvent(static_cast<QEvent*>(event));
}

void QShortcut_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QShortcut*>(ptr), "deleteLater");
}

void QShortcut_DeleteLaterDefault(void* ptr)
{
	static_cast<QShortcut*>(ptr)->QShortcut::deleteLater();
}

void QShortcut_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QShortcut*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QShortcut_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QShortcut*>(ptr)->QShortcut::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QShortcut_Event(void* ptr, void* e)
{
	return static_cast<QShortcut*>(ptr)->event(static_cast<QEvent*>(e));
}

char QShortcut_EventDefault(void* ptr, void* e)
{
	return static_cast<QShortcut*>(ptr)->QShortcut::event(static_cast<QEvent*>(e));
}

char QShortcut_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QShortcut*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QShortcut_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QShortcut*>(ptr)->QShortcut::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QShortcut_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QShortcut*>(ptr)->metaObject());
}

void* QShortcut_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QShortcut*>(ptr)->QShortcut::metaObject());
}

class MyQSizeGrip: public QSizeGrip
{
public:
	MyQSizeGrip(QWidget *parent) : QSizeGrip(parent) {};
	void mouseMoveEvent(QMouseEvent * event) { callbackQSizeGrip_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQSizeGrip_MousePressEvent(this, event); };
	void hideEvent(QHideEvent * hideEvent) { callbackQSizeGrip_HideEvent(this, hideEvent); };
	void mouseReleaseEvent(QMouseEvent * mouseEvent) { callbackQSizeGrip_MouseReleaseEvent(this, mouseEvent); };
	void moveEvent(QMoveEvent * moveEvent) { callbackQSizeGrip_MoveEvent(this, moveEvent); };
	void paintEvent(QPaintEvent * event) { callbackQSizeGrip_PaintEvent(this, event); };
	void setVisible(bool visible) { callbackQSizeGrip_SetVisible(this, visible); };
	void showEvent(QShowEvent * showEvent) { callbackQSizeGrip_ShowEvent(this, showEvent); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQSizeGrip_SizeHint(const_cast<MyQSizeGrip*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQSizeGrip_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQSizeGrip_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQSizeGrip_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQSizeGrip_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQSizeGrip_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQSizeGrip_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQSizeGrip_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQSizeGrip_FocusOutEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQSizeGrip_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQSizeGrip_MinimumSizeHint(const_cast<MyQSizeGrip*>(this))); };
	void setEnabled(bool vbo) { callbackQSizeGrip_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQSizeGrip_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setWindowModified(bool vbo) { callbackQSizeGrip_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQSizeGrip_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void changeEvent(QEvent * event) { callbackQSizeGrip_ChangeEvent(this, event); };
	bool close() { return callbackQSizeGrip_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQSizeGrip_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQSizeGrip_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQSizeGrip_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQSizeGrip_HasHeightForWidth(const_cast<MyQSizeGrip*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQSizeGrip_HeightForWidth(const_cast<MyQSizeGrip*>(this), w); };
	void hide() { callbackQSizeGrip_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQSizeGrip_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQSizeGrip_InputMethodQuery(const_cast<MyQSizeGrip*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQSizeGrip_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQSizeGrip_KeyReleaseEvent(this, event); };
	void lower() { callbackQSizeGrip_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQSizeGrip_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQSizeGrip_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQSizeGrip_Raise(this); };
	void repaint() { callbackQSizeGrip_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQSizeGrip_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQSizeGrip_SetDisabled(this, disable); };
	void setFocus() { callbackQSizeGrip_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQSizeGrip_SetHidden(this, hidden); };
	void show() { callbackQSizeGrip_Show(this); };
	void showFullScreen() { callbackQSizeGrip_ShowFullScreen(this); };
	void showMaximized() { callbackQSizeGrip_ShowMaximized(this); };
	void showMinimized() { callbackQSizeGrip_ShowMinimized(this); };
	void showNormal() { callbackQSizeGrip_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQSizeGrip_TabletEvent(this, event); };
	void update() { callbackQSizeGrip_Update(this); };
	void updateMicroFocus() { callbackQSizeGrip_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQSizeGrip_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQSizeGrip_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQSizeGrip_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQSizeGrip_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQSizeGrip_CustomEvent(this, event); };
	void deleteLater() { callbackQSizeGrip_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQSizeGrip_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSizeGrip_MetaObject(const_cast<MyQSizeGrip*>(this))); };
};

void QSizeGrip_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QSizeGrip_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QSizeGrip_MousePressEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QSizeGrip_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void* QSizeGrip_NewQSizeGrip(void* parent)
{
	return new MyQSizeGrip(static_cast<QWidget*>(parent));
}

char QSizeGrip_Event(void* ptr, void* event)
{
	return static_cast<QSizeGrip*>(ptr)->event(static_cast<QEvent*>(event));
}

char QSizeGrip_EventFilter(void* ptr, void* o, void* e)
{
	return static_cast<QSizeGrip*>(ptr)->eventFilter(static_cast<QObject*>(o), static_cast<QEvent*>(e));
}

void QSizeGrip_HideEvent(void* ptr, void* hideEvent)
{
	static_cast<QSizeGrip*>(ptr)->hideEvent(static_cast<QHideEvent*>(hideEvent));
}

void QSizeGrip_HideEventDefault(void* ptr, void* hideEvent)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::hideEvent(static_cast<QHideEvent*>(hideEvent));
}

void QSizeGrip_MouseReleaseEvent(void* ptr, void* mouseEvent)
{
	static_cast<QSizeGrip*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(mouseEvent));
}

void QSizeGrip_MouseReleaseEventDefault(void* ptr, void* mouseEvent)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::mouseReleaseEvent(static_cast<QMouseEvent*>(mouseEvent));
}

void QSizeGrip_MoveEvent(void* ptr, void* moveEvent)
{
	static_cast<QSizeGrip*>(ptr)->moveEvent(static_cast<QMoveEvent*>(moveEvent));
}

void QSizeGrip_MoveEventDefault(void* ptr, void* moveEvent)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::moveEvent(static_cast<QMoveEvent*>(moveEvent));
}

void QSizeGrip_PaintEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QSizeGrip_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::paintEvent(static_cast<QPaintEvent*>(event));
}

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_ShowEvent(void* ptr, void* showEvent)
{
	static_cast<QSizeGrip*>(ptr)->showEvent(static_cast<QShowEvent*>(showEvent));
}

void QSizeGrip_ShowEventDefault(void* ptr, void* showEvent)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::showEvent(static_cast<QShowEvent*>(showEvent));
}

void* QSizeGrip_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSizeGrip*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSizeGrip_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSizeGrip*>(ptr)->QSizeGrip::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QSizeGrip_DestroyQSizeGrip(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->~QSizeGrip();
}

void QSizeGrip_ActionEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QSizeGrip_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::actionEvent(static_cast<QActionEvent*>(event));
}

void QSizeGrip_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QSizeGrip_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QSizeGrip_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QSizeGrip_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QSizeGrip_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QSizeGrip_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QSizeGrip_DropEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QSizeGrip_DropEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::dropEvent(static_cast<QDropEvent*>(event));
}

void QSizeGrip_EnterEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QSizeGrip_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::enterEvent(static_cast<QEvent*>(event));
}

void QSizeGrip_FocusInEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QSizeGrip_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QSizeGrip_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QSizeGrip_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QSizeGrip_LeaveEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QSizeGrip_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::leaveEvent(static_cast<QEvent*>(event));
}

void* QSizeGrip_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSizeGrip*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSizeGrip_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSizeGrip*>(ptr)->QSizeGrip::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QSizeGrip_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QSizeGrip_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::setEnabled(vbo != 0);
}

void QSizeGrip_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QSizeGrip_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::setStyleSheet(QString(styleSheet));
}

void QSizeGrip_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QSizeGrip_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::setWindowModified(vbo != 0);
}

void QSizeGrip_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QSizeGrip_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::setWindowTitle(QString(vqs));
}

void QSizeGrip_ChangeEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QSizeGrip_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::changeEvent(static_cast<QEvent*>(event));
}

char QSizeGrip_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QSizeGrip_CloseDefault(void* ptr)
{
	return static_cast<QSizeGrip*>(ptr)->QSizeGrip::close();
}

void QSizeGrip_CloseEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QSizeGrip_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::closeEvent(static_cast<QCloseEvent*>(event));
}

void QSizeGrip_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QSizeGrip_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QSizeGrip_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QSizeGrip*>(ptr)->focusNextPrevChild(next != 0);
}

char QSizeGrip_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QSizeGrip*>(ptr)->QSizeGrip::focusNextPrevChild(next != 0);
}

char QSizeGrip_HasHeightForWidth(void* ptr)
{
	return static_cast<QSizeGrip*>(ptr)->hasHeightForWidth();
}

char QSizeGrip_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QSizeGrip*>(ptr)->QSizeGrip::hasHeightForWidth();
}

int QSizeGrip_HeightForWidth(void* ptr, int w)
{
	return static_cast<QSizeGrip*>(ptr)->heightForWidth(w);
}

int QSizeGrip_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QSizeGrip*>(ptr)->QSizeGrip::heightForWidth(w);
}

void QSizeGrip_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "hide");
}

void QSizeGrip_HideDefault(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::hide();
}

void QSizeGrip_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QSizeGrip_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QSizeGrip_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QSizeGrip*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QSizeGrip_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QSizeGrip*>(ptr)->QSizeGrip::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QSizeGrip_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QSizeGrip_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QSizeGrip_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QSizeGrip_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QSizeGrip_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "lower");
}

void QSizeGrip_LowerDefault(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::lower();
}

void QSizeGrip_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QSizeGrip_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QSizeGrip_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QSizeGrip*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QSizeGrip_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QSizeGrip*>(ptr)->QSizeGrip::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QSizeGrip_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "raise");
}

void QSizeGrip_RaiseDefault(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::raise();
}

void QSizeGrip_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "repaint");
}

void QSizeGrip_RepaintDefault(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::repaint();
}

void QSizeGrip_ResizeEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QSizeGrip_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QSizeGrip_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QSizeGrip_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::setDisabled(disable != 0);
}

void QSizeGrip_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "setFocus");
}

void QSizeGrip_SetFocus2Default(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::setFocus();
}

void QSizeGrip_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QSizeGrip_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::setHidden(hidden != 0);
}

void QSizeGrip_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "show");
}

void QSizeGrip_ShowDefault(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::show();
}

void QSizeGrip_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "showFullScreen");
}

void QSizeGrip_ShowFullScreenDefault(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::showFullScreen();
}

void QSizeGrip_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "showMaximized");
}

void QSizeGrip_ShowMaximizedDefault(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::showMaximized();
}

void QSizeGrip_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "showMinimized");
}

void QSizeGrip_ShowMinimizedDefault(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::showMinimized();
}

void QSizeGrip_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "showNormal");
}

void QSizeGrip_ShowNormalDefault(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::showNormal();
}

void QSizeGrip_TabletEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QSizeGrip_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QSizeGrip_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "update");
}

void QSizeGrip_UpdateDefault(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::update();
}

void QSizeGrip_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "updateMicroFocus");
}

void QSizeGrip_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::updateMicroFocus();
}

void QSizeGrip_WheelEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QSizeGrip_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QSizeGrip_TimerEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QSizeGrip_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::timerEvent(static_cast<QTimerEvent*>(event));
}

void QSizeGrip_ChildEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QSizeGrip_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::childEvent(static_cast<QChildEvent*>(event));
}

void QSizeGrip_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QSizeGrip*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSizeGrip_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSizeGrip_CustomEvent(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QSizeGrip_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::customEvent(static_cast<QEvent*>(event));
}

void QSizeGrip_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "deleteLater");
}

void QSizeGrip_DeleteLaterDefault(void* ptr)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::deleteLater();
}

void QSizeGrip_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QSizeGrip*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSizeGrip_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSizeGrip*>(ptr)->QSizeGrip::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void* QSizeGrip_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSizeGrip*>(ptr)->metaObject());
}

void* QSizeGrip_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSizeGrip*>(ptr)->QSizeGrip::metaObject());
}

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();
}

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) : QSlider(parent) {};
	MyQSlider(Qt::Orientation orientation, QWidget *parent) : QSlider(orientation, parent) {};
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQSlider_MinimumSizeHint(const_cast<MyQSlider*>(this))); };
	void mouseMoveEvent(QMouseEvent * ev) { callbackQSlider_MouseMoveEvent(this, ev); };
	void mousePressEvent(QMouseEvent * ev) { callbackQSlider_MousePressEvent(this, ev); };
	void mouseReleaseEvent(QMouseEvent * ev) { callbackQSlider_MouseReleaseEvent(this, ev); };
	void paintEvent(QPaintEvent * ev) { callbackQSlider_PaintEvent(this, ev); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQSlider_SizeHint(const_cast<MyQSlider*>(this))); };
	void setOrientation(Qt::Orientation vqt) { callbackQSlider_SetOrientation(this, vqt); };
	void setValue(int vin) { callbackQSlider_SetValue(this, vin); };
	void changeEvent(QEvent * ev) { callbackQSlider_ChangeEvent(this, ev); };
	void keyPressEvent(QKeyEvent * ev) { callbackQSlider_KeyPressEvent(this, ev); };
	void setRange(int min, int max) { callbackQSlider_SetRange(this, min, max); };
	void sliderChange(QAbstractSlider::SliderChange change) { callbackQSlider_SliderChange(this, change); };
	void wheelEvent(QWheelEvent * e) { callbackQSlider_WheelEvent(this, e); };
	void actionEvent(QActionEvent * event) { callbackQSlider_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQSlider_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQSlider_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQSlider_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQSlider_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQSlider_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQSlider_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQSlider_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQSlider_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQSlider_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQSlider_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQSlider_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQSlider_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQSlider_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQSlider_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQSlider_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQSlider_ShowEvent(this, event); };
	bool close() { return callbackQSlider_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQSlider_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQSlider_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQSlider_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQSlider_HasHeightForWidth(const_cast<MyQSlider*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQSlider_HeightForWidth(const_cast<MyQSlider*>(this), w); };
	void hide() { callbackQSlider_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQSlider_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQSlider_InputMethodQuery(const_cast<MyQSlider*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQSlider_KeyReleaseEvent(this, event); };
	void lower() { callbackQSlider_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQSlider_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQSlider_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQSlider_Raise(this); };
	void repaint() { callbackQSlider_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQSlider_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQSlider_SetDisabled(this, disable); };
	void setFocus() { callbackQSlider_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQSlider_SetHidden(this, hidden); };
	void show() { callbackQSlider_Show(this); };
	void showFullScreen() { callbackQSlider_ShowFullScreen(this); };
	void showMaximized() { callbackQSlider_ShowMaximized(this); };
	void showMinimized() { callbackQSlider_ShowMinimized(this); };
	void showNormal() { callbackQSlider_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQSlider_TabletEvent(this, event); };
	void update() { callbackQSlider_Update(this); };
	void updateMicroFocus() { callbackQSlider_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQSlider_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQSlider_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQSlider_CustomEvent(this, event); };
	void deleteLater() { callbackQSlider_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQSlider_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSlider_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSlider_MetaObject(const_cast<MyQSlider*>(this))); };
};

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_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));
}

char QSlider_Event(void* ptr, void* event)
{
	return static_cast<QSlider*>(ptr)->event(static_cast<QEvent*>(event));
}

void QSlider_InitStyleOption(void* ptr, void* option)
{
	static_cast<QSlider*>(ptr)->initStyleOption(static_cast<QStyleOptionSlider*>(option));
}

void* QSlider_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSlider*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSlider_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSlider*>(ptr)->QSlider::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QSlider_MouseMoveEvent(void* ptr, void* ev)
{
	static_cast<QSlider*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(ev));
}

void QSlider_MouseMoveEventDefault(void* ptr, void* ev)
{
	static_cast<QSlider*>(ptr)->QSlider::mouseMoveEvent(static_cast<QMouseEvent*>(ev));
}

void QSlider_MousePressEvent(void* ptr, void* ev)
{
	static_cast<QSlider*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(ev));
}

void QSlider_MousePressEventDefault(void* ptr, void* ev)
{
	static_cast<QSlider*>(ptr)->QSlider::mousePressEvent(static_cast<QMouseEvent*>(ev));
}

void QSlider_MouseReleaseEvent(void* ptr, void* ev)
{
	static_cast<QSlider*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
}

void QSlider_MouseReleaseEventDefault(void* ptr, void* ev)
{
	static_cast<QSlider*>(ptr)->QSlider::mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
}

void QSlider_PaintEvent(void* ptr, void* ev)
{
	static_cast<QSlider*>(ptr)->paintEvent(static_cast<QPaintEvent*>(ev));
}

void QSlider_PaintEventDefault(void* ptr, void* ev)
{
	static_cast<QSlider*>(ptr)->QSlider::paintEvent(static_cast<QPaintEvent*>(ev));
}

void* QSlider_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSlider*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSlider_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSlider*>(ptr)->QSlider::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QSlider_DestroyQSlider(void* ptr)
{
	static_cast<QSlider*>(ptr)->~QSlider();
}

void QSlider_SetOrientation(void* ptr, long long vqt)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setOrientation", Q_ARG(Qt::Orientation, static_cast<Qt::Orientation>(vqt)));
}

void QSlider_SetOrientationDefault(void* ptr, long long vqt)
{
	static_cast<QSlider*>(ptr)->QSlider::setOrientation(static_cast<Qt::Orientation>(vqt));
}

void QSlider_SetValue(void* ptr, int vin)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setValue", Q_ARG(int, vin));
}

void QSlider_SetValueDefault(void* ptr, int vin)
{
	static_cast<QSlider*>(ptr)->QSlider::setValue(vin);
}

void QSlider_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QSlider*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QSlider_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QSlider*>(ptr)->QSlider::changeEvent(static_cast<QEvent*>(ev));
}

void QSlider_KeyPressEvent(void* ptr, void* ev)
{
	static_cast<QSlider*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(ev));
}

void QSlider_KeyPressEventDefault(void* ptr, void* ev)
{
	static_cast<QSlider*>(ptr)->QSlider::keyPressEvent(static_cast<QKeyEvent*>(ev));
}

void QSlider_SetRange(void* ptr, int min, int max)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setRange", Q_ARG(int, min), Q_ARG(int, max));
}

void QSlider_SetRangeDefault(void* ptr, int min, int max)
{
	static_cast<QSlider*>(ptr)->QSlider::setRange(min, max);
}

void QSlider_SliderChange(void* ptr, long long change)
{
	static_cast<QSlider*>(ptr)->sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
}

void QSlider_SliderChangeDefault(void* ptr, long long change)
{
	static_cast<QSlider*>(ptr)->QSlider::sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
}

void QSlider_WheelEvent(void* ptr, void* e)
{
	static_cast<QSlider*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QSlider_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QSlider*>(ptr)->QSlider::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QSlider_ActionEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QSlider_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::actionEvent(static_cast<QActionEvent*>(event));
}

void QSlider_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QSlider_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QSlider_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QSlider_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QSlider_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QSlider_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QSlider_DropEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QSlider_DropEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::dropEvent(static_cast<QDropEvent*>(event));
}

void QSlider_EnterEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QSlider_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::enterEvent(static_cast<QEvent*>(event));
}

void QSlider_FocusInEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QSlider_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QSlider_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QSlider_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QSlider_HideEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QSlider_HideEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::hideEvent(static_cast<QHideEvent*>(event));
}

void QSlider_LeaveEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QSlider_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::leaveEvent(static_cast<QEvent*>(event));
}

void QSlider_MoveEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QSlider_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::moveEvent(static_cast<QMoveEvent*>(event));
}

void QSlider_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QSlider_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QSlider*>(ptr)->QSlider::setEnabled(vbo != 0);
}

void QSlider_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QSlider_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QSlider*>(ptr)->QSlider::setStyleSheet(QString(styleSheet));
}

void QSlider_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QSlider_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QSlider*>(ptr)->QSlider::setVisible(visible != 0);
}

void QSlider_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QSlider_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QSlider*>(ptr)->QSlider::setWindowModified(vbo != 0);
}

void QSlider_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QSlider_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QSlider*>(ptr)->QSlider::setWindowTitle(QString(vqs));
}

void QSlider_ShowEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QSlider_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::showEvent(static_cast<QShowEvent*>(event));
}

char QSlider_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QSlider_CloseDefault(void* ptr)
{
	return static_cast<QSlider*>(ptr)->QSlider::close();
}

void QSlider_CloseEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QSlider_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::closeEvent(static_cast<QCloseEvent*>(event));
}

void QSlider_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QSlider_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QSlider_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QSlider*>(ptr)->focusNextPrevChild(next != 0);
}

char QSlider_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QSlider*>(ptr)->QSlider::focusNextPrevChild(next != 0);
}

char QSlider_HasHeightForWidth(void* ptr)
{
	return static_cast<QSlider*>(ptr)->hasHeightForWidth();
}

char QSlider_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QSlider*>(ptr)->QSlider::hasHeightForWidth();
}

int QSlider_HeightForWidth(void* ptr, int w)
{
	return static_cast<QSlider*>(ptr)->heightForWidth(w);
}

int QSlider_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QSlider*>(ptr)->QSlider::heightForWidth(w);
}

void QSlider_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "hide");
}

void QSlider_HideDefault(void* ptr)
{
	static_cast<QSlider*>(ptr)->QSlider::hide();
}

void QSlider_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QSlider_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QSlider_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QSlider*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QSlider_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QSlider*>(ptr)->QSlider::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QSlider_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QSlider_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QSlider_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "lower");
}

void QSlider_LowerDefault(void* ptr)
{
	static_cast<QSlider*>(ptr)->QSlider::lower();
}

void QSlider_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QSlider_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QSlider_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QSlider*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QSlider_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QSlider*>(ptr)->QSlider::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QSlider_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "raise");
}

void QSlider_RaiseDefault(void* ptr)
{
	static_cast<QSlider*>(ptr)->QSlider::raise();
}

void QSlider_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "repaint");
}

void QSlider_RepaintDefault(void* ptr)
{
	static_cast<QSlider*>(ptr)->QSlider::repaint();
}

void QSlider_ResizeEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QSlider_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QSlider_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QSlider_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QSlider*>(ptr)->QSlider::setDisabled(disable != 0);
}

void QSlider_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setFocus");
}

void QSlider_SetFocus2Default(void* ptr)
{
	static_cast<QSlider*>(ptr)->QSlider::setFocus();
}

void QSlider_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QSlider_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QSlider*>(ptr)->QSlider::setHidden(hidden != 0);
}

void QSlider_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "show");
}

void QSlider_ShowDefault(void* ptr)
{
	static_cast<QSlider*>(ptr)->QSlider::show();
}

void QSlider_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "showFullScreen");
}

void QSlider_ShowFullScreenDefault(void* ptr)
{
	static_cast<QSlider*>(ptr)->QSlider::showFullScreen();
}

void QSlider_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "showMaximized");
}

void QSlider_ShowMaximizedDefault(void* ptr)
{
	static_cast<QSlider*>(ptr)->QSlider::showMaximized();
}

void QSlider_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "showMinimized");
}

void QSlider_ShowMinimizedDefault(void* ptr)
{
	static_cast<QSlider*>(ptr)->QSlider::showMinimized();
}

void QSlider_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "showNormal");
}

void QSlider_ShowNormalDefault(void* ptr)
{
	static_cast<QSlider*>(ptr)->QSlider::showNormal();
}

void QSlider_TabletEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QSlider_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QSlider_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "update");
}

void QSlider_UpdateDefault(void* ptr)
{
	static_cast<QSlider*>(ptr)->QSlider::update();
}

void QSlider_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "updateMicroFocus");
}

void QSlider_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QSlider*>(ptr)->QSlider::updateMicroFocus();
}

void QSlider_ChildEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QSlider_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::childEvent(static_cast<QChildEvent*>(event));
}

void QSlider_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QSlider*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSlider_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSlider*>(ptr)->QSlider::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSlider_CustomEvent(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QSlider_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QSlider*>(ptr)->QSlider::customEvent(static_cast<QEvent*>(event));
}

void QSlider_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "deleteLater");
}

void QSlider_DeleteLaterDefault(void* ptr)
{
	static_cast<QSlider*>(ptr)->QSlider::deleteLater();
}

void QSlider_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QSlider*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSlider_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSlider*>(ptr)->QSlider::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QSlider_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QSlider*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QSlider_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QSlider*>(ptr)->QSlider::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QSlider_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSlider*>(ptr)->metaObject());
}

void* QSlider_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSlider*>(ptr)->QSlider::metaObject());
}

class MyQSpacerItem: public QSpacerItem
{
public:
	MyQSpacerItem(int w, int h, QSizePolicy::Policy hPolicy, QSizePolicy::Policy vPolicy) : QSpacerItem(w, h, hPolicy, vPolicy) {};
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQSpacerItem_ExpandingDirections(const_cast<MyQSpacerItem*>(this))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQSpacerItem_Geometry(const_cast<MyQSpacerItem*>(this))); };
	bool isEmpty() const { return callbackQSpacerItem_IsEmpty(const_cast<MyQSpacerItem*>(this)) != 0; };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQSpacerItem_MaximumSize(const_cast<MyQSpacerItem*>(this))); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQSpacerItem_MinimumSize(const_cast<MyQSpacerItem*>(this))); };
	void setGeometry(const QRect & r) { callbackQSpacerItem_SetGeometry(this, const_cast<QRect*>(&r)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQSpacerItem_SizeHint(const_cast<MyQSpacerItem*>(this))); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQSpacerItem_SpacerItem(this)); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQSpacerItem_ControlTypes(const_cast<MyQSpacerItem*>(this))); };
	bool hasHeightForWidth() const { return callbackQSpacerItem_HasHeightForWidth(const_cast<MyQSpacerItem*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQSpacerItem_HeightForWidth(const_cast<MyQSpacerItem*>(this), w); };
	void invalidate() { callbackQSpacerItem_Invalidate(this); };
	QLayout * layout() { return static_cast<QLayout*>(callbackQSpacerItem_Layout(this)); };
	int minimumHeightForWidth(int w) const { return callbackQSpacerItem_MinimumHeightForWidth(const_cast<MyQSpacerItem*>(this), w); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQSpacerItem_Widget(this)); };
};

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_SpacerItem(void* ptr)
{
	return static_cast<QSpacerItem*>(ptr)->spacerItem();
}

void* QSpacerItem_SpacerItemDefault(void* ptr)
{
	return static_cast<QSpacerItem*>(ptr)->QSpacerItem::spacerItem();
}

void QSpacerItem_DestroyQSpacerItem(void* ptr)
{
	static_cast<QSpacerItem*>(ptr)->~QSpacerItem();
}

long long QSpacerItem_ControlTypes(void* ptr)
{
	return static_cast<QSpacerItem*>(ptr)->controlTypes();
}

long long QSpacerItem_ControlTypesDefault(void* ptr)
{
	return static_cast<QSpacerItem*>(ptr)->QSpacerItem::controlTypes();
}

char QSpacerItem_HasHeightForWidth(void* ptr)
{
	return static_cast<QSpacerItem*>(ptr)->hasHeightForWidth();
}

char QSpacerItem_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QSpacerItem*>(ptr)->QSpacerItem::hasHeightForWidth();
}

int QSpacerItem_HeightForWidth(void* ptr, int w)
{
	return static_cast<QSpacerItem*>(ptr)->heightForWidth(w);
}

int QSpacerItem_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QSpacerItem*>(ptr)->QSpacerItem::heightForWidth(w);
}

void QSpacerItem_Invalidate(void* ptr)
{
	static_cast<QSpacerItem*>(ptr)->invalidate();
}

void QSpacerItem_InvalidateDefault(void* ptr)
{
	static_cast<QSpacerItem*>(ptr)->QSpacerItem::invalidate();
}

void* QSpacerItem_Layout(void* ptr)
{
	return static_cast<QSpacerItem*>(ptr)->layout();
}

void* QSpacerItem_LayoutDefault(void* ptr)
{
	return static_cast<QSpacerItem*>(ptr)->QSpacerItem::layout();
}

int QSpacerItem_MinimumHeightForWidth(void* ptr, int w)
{
	return static_cast<QSpacerItem*>(ptr)->minimumHeightForWidth(w);
}

int QSpacerItem_MinimumHeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QSpacerItem*>(ptr)->QSpacerItem::minimumHeightForWidth(w);
}

void* QSpacerItem_Widget(void* ptr)
{
	return static_cast<QSpacerItem*>(ptr)->widget();
}

void* QSpacerItem_WidgetDefault(void* ptr)
{
	return static_cast<QSpacerItem*>(ptr)->QSpacerItem::widget();
}

class MyQSpinBox: public QSpinBox
{
public:
	MyQSpinBox(QWidget *parent) : QSpinBox(parent) {};
	void setValue(int val) { callbackQSpinBox_SetValue(this, val); };
	int valueFromText(const QString & text) const { return callbackQSpinBox_ValueFromText(const_cast<MyQSpinBox*>(this), const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void fixup(QString & input) const { callbackQSpinBox_Fixup(const_cast<MyQSpinBox*>(this), const_cast<char*>(input.toUtf8().prepend("WHITESPACE").constData()+10)); };
	QString textFromValue(int value) const { return QString(callbackQSpinBox_TextFromValue(const_cast<MyQSpinBox*>(this), value)); };
	QValidator::State validate(QString & text, int & pos) const { return static_cast<QValidator::State>(callbackQSpinBox_Validate(const_cast<MyQSpinBox*>(this), const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10), pos)); };
	void Signal_ValueChanged2(const QString & text) { callbackQSpinBox_ValueChanged2(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_ValueChanged(int i) { callbackQSpinBox_ValueChanged(this, i); };
	void changeEvent(QEvent * event) { callbackQSpinBox_ChangeEvent(this, event); };
	void clear() { callbackQSpinBox_Clear(this); };
	void closeEvent(QCloseEvent * event) { callbackQSpinBox_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQSpinBox_ContextMenuEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQSpinBox_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQSpinBox_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQSpinBox_HideEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQSpinBox_InputMethodQuery(const_cast<MyQSpinBox*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQSpinBox_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQSpinBox_KeyReleaseEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQSpinBox_MinimumSizeHint(const_cast<MyQSpinBox*>(this))); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQSpinBox_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQSpinBox_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQSpinBox_MouseReleaseEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQSpinBox_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQSpinBox_ResizeEvent(this, event); };
	void selectAll() { callbackQSpinBox_SelectAll(this); };
	void showEvent(QShowEvent * event) { callbackQSpinBox_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQSpinBox_SizeHint(const_cast<MyQSpinBox*>(this))); };
	void stepBy(int steps) { callbackQSpinBox_StepBy(this, steps); };
	void stepDown() { callbackQSpinBox_StepDown(this); };
	StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQSpinBox_StepEnabled(const_cast<MyQSpinBox*>(this))); };
	void stepUp() { callbackQSpinBox_StepUp(this); };
	void wheelEvent(QWheelEvent * event) { callbackQSpinBox_WheelEvent(this, event); };
	void actionEvent(QActionEvent * event) { callbackQSpinBox_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQSpinBox_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQSpinBox_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQSpinBox_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQSpinBox_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQSpinBox_EnterEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQSpinBox_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQSpinBox_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQSpinBox_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQSpinBox_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQSpinBox_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQSpinBox_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQSpinBox_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQSpinBox_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQSpinBox_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQSpinBox_HasHeightForWidth(const_cast<MyQSpinBox*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQSpinBox_HeightForWidth(const_cast<MyQSpinBox*>(this), w); };
	void hide() { callbackQSpinBox_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQSpinBox_InputMethodEvent(this, event); };
	void lower() { callbackQSpinBox_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQSpinBox_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQSpinBox_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQSpinBox_Raise(this); };
	void repaint() { callbackQSpinBox_Repaint(this); };
	void setDisabled(bool disable) { callbackQSpinBox_SetDisabled(this, disable); };
	void setFocus() { callbackQSpinBox_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQSpinBox_SetHidden(this, hidden); };
	void show() { callbackQSpinBox_Show(this); };
	void showFullScreen() { callbackQSpinBox_ShowFullScreen(this); };
	void showMaximized() { callbackQSpinBox_ShowMaximized(this); };
	void showMinimized() { callbackQSpinBox_ShowMinimized(this); };
	void showNormal() { callbackQSpinBox_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQSpinBox_TabletEvent(this, event); };
	void update() { callbackQSpinBox_Update(this); };
	void updateMicroFocus() { callbackQSpinBox_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQSpinBox_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQSpinBox_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQSpinBox_CustomEvent(this, event); };
	void deleteLater() { callbackQSpinBox_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQSpinBox_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSpinBox_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSpinBox_MetaObject(const_cast<MyQSpinBox*>(this))); };
};

char* QSpinBox_CleanText(void* ptr)
{
	return const_cast<char*>(static_cast<QSpinBox*>(ptr)->cleanText().toUtf8().prepend("WHITESPACE").constData()+10);
}

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();
}

char* QSpinBox_Prefix(void* ptr)
{
	return const_cast<char*>(static_cast<QSpinBox*>(ptr)->prefix().toUtf8().prepend("WHITESPACE").constData()+10);
}

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, char* prefix)
{
	static_cast<QSpinBox*>(ptr)->setPrefix(QString(prefix));
}

void QSpinBox_SetSingleStep(void* ptr, int val)
{
	static_cast<QSpinBox*>(ptr)->setSingleStep(val);
}

void QSpinBox_SetSuffix(void* ptr, char* suffix)
{
	static_cast<QSpinBox*>(ptr)->setSuffix(QString(suffix));
}

void QSpinBox_SetValue(void* ptr, int val)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setValue", Q_ARG(int, val));
}

int QSpinBox_SingleStep(void* ptr)
{
	return static_cast<QSpinBox*>(ptr)->singleStep();
}

char* QSpinBox_Suffix(void* ptr)
{
	return const_cast<char*>(static_cast<QSpinBox*>(ptr)->suffix().toUtf8().prepend("WHITESPACE").constData()+10);
}

int QSpinBox_Value(void* ptr)
{
	return static_cast<QSpinBox*>(ptr)->value();
}

int QSpinBox_ValueFromText(void* ptr, char* text)
{
	return static_cast<QSpinBox*>(ptr)->valueFromText(QString(text));
}

int QSpinBox_ValueFromTextDefault(void* ptr, char* text)
{
	return static_cast<QSpinBox*>(ptr)->QSpinBox::valueFromText(QString(text));
}

void* QSpinBox_NewQSpinBox(void* parent)
{
	return new MyQSpinBox(static_cast<QWidget*>(parent));
}

char QSpinBox_Event(void* ptr, void* event)
{
	return static_cast<QSpinBox*>(ptr)->event(static_cast<QEvent*>(event));
}

void QSpinBox_Fixup(void* ptr, char* input)
{
	static_cast<QSpinBox*>(ptr)->fixup(*(new QString(input)));
}

void QSpinBox_FixupDefault(void* ptr, char* input)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::fixup(*(new QString(input)));
}

void QSpinBox_SetRange(void* ptr, int minimum, int maximum)
{
	static_cast<QSpinBox*>(ptr)->setRange(minimum, maximum);
}

char* QSpinBox_TextFromValue(void* ptr, int value)
{
	return const_cast<char*>(static_cast<QSpinBox*>(ptr)->textFromValue(value).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QSpinBox_TextFromValueDefault(void* ptr, int value)
{
	return const_cast<char*>(static_cast<QSpinBox*>(ptr)->QSpinBox::textFromValue(value).toUtf8().prepend("WHITESPACE").constData()+10);
}

long long QSpinBox_Validate(void* ptr, char* text, int pos)
{
	return static_cast<QSpinBox*>(ptr)->validate(*(new QString(text)), pos);
}

long long QSpinBox_ValidateDefault(void* ptr, char* text, int pos)
{
	return static_cast<QSpinBox*>(ptr)->QSpinBox::validate(*(new QString(text)), pos);
}

void QSpinBox_ConnectValueChanged2(void* ptr)
{
	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));
}

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, char* text)
{
	static_cast<QSpinBox*>(ptr)->valueChanged(QString(text));
}

void QSpinBox_ConnectValueChanged(void* ptr)
{
	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));
}

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_DestroyQSpinBox(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->~QSpinBox();
}

void QSpinBox_ChangeEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QSpinBox_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::changeEvent(static_cast<QEvent*>(event));
}

void QSpinBox_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "clear");
}

void QSpinBox_ClearDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::clear();
}

void QSpinBox_CloseEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QSpinBox_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::closeEvent(static_cast<QCloseEvent*>(event));
}

void QSpinBox_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QSpinBox_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QSpinBox_FocusInEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QSpinBox_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QSpinBox_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QSpinBox_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QSpinBox_HideEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QSpinBox_HideEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::hideEvent(static_cast<QHideEvent*>(event));
}

void* QSpinBox_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QSpinBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QSpinBox_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QSpinBox*>(ptr)->QSpinBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QSpinBox_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QSpinBox_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QSpinBox_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QSpinBox_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void* QSpinBox_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSpinBox*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSpinBox_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSpinBox*>(ptr)->QSpinBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QSpinBox_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QSpinBox_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QSpinBox_MousePressEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QSpinBox_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QSpinBox_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QSpinBox_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QSpinBox_PaintEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QSpinBox_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::paintEvent(static_cast<QPaintEvent*>(event));
}

void QSpinBox_ResizeEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QSpinBox_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QSpinBox_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "selectAll");
}

void QSpinBox_SelectAllDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::selectAll();
}

void QSpinBox_ShowEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QSpinBox_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::showEvent(static_cast<QShowEvent*>(event));
}

void* QSpinBox_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSpinBox*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSpinBox_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSpinBox*>(ptr)->QSpinBox::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QSpinBox_StepBy(void* ptr, int steps)
{
	static_cast<QSpinBox*>(ptr)->stepBy(steps);
}

void QSpinBox_StepByDefault(void* ptr, int steps)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::stepBy(steps);
}

void QSpinBox_StepDown(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "stepDown");
}

void QSpinBox_StepDownDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::stepDown();
}

long long QSpinBox_StepEnabled(void* ptr)
{
	return static_cast<QSpinBox*>(ptr)->stepEnabled();
}

long long QSpinBox_StepEnabledDefault(void* ptr)
{
	return static_cast<QSpinBox*>(ptr)->QSpinBox::stepEnabled();
}

void QSpinBox_StepUp(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "stepUp");
}

void QSpinBox_StepUpDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::stepUp();
}

void QSpinBox_WheelEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QSpinBox_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QSpinBox_ActionEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QSpinBox_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::actionEvent(static_cast<QActionEvent*>(event));
}

void QSpinBox_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QSpinBox_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QSpinBox_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QSpinBox_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QSpinBox_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QSpinBox_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QSpinBox_DropEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QSpinBox_DropEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::dropEvent(static_cast<QDropEvent*>(event));
}

void QSpinBox_EnterEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QSpinBox_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::enterEvent(static_cast<QEvent*>(event));
}

void QSpinBox_LeaveEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QSpinBox_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::leaveEvent(static_cast<QEvent*>(event));
}

void QSpinBox_MoveEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QSpinBox_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::moveEvent(static_cast<QMoveEvent*>(event));
}

void QSpinBox_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QSpinBox_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::setEnabled(vbo != 0);
}

void QSpinBox_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QSpinBox_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::setStyleSheet(QString(styleSheet));
}

void QSpinBox_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QSpinBox_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::setVisible(visible != 0);
}

void QSpinBox_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QSpinBox_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::setWindowModified(vbo != 0);
}

void QSpinBox_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QSpinBox_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::setWindowTitle(QString(vqs));
}

char QSpinBox_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QSpinBox_CloseDefault(void* ptr)
{
	return static_cast<QSpinBox*>(ptr)->QSpinBox::close();
}

char QSpinBox_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QSpinBox*>(ptr)->focusNextPrevChild(next != 0);
}

char QSpinBox_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QSpinBox*>(ptr)->QSpinBox::focusNextPrevChild(next != 0);
}

char QSpinBox_HasHeightForWidth(void* ptr)
{
	return static_cast<QSpinBox*>(ptr)->hasHeightForWidth();
}

char QSpinBox_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QSpinBox*>(ptr)->QSpinBox::hasHeightForWidth();
}

int QSpinBox_HeightForWidth(void* ptr, int w)
{
	return static_cast<QSpinBox*>(ptr)->heightForWidth(w);
}

int QSpinBox_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QSpinBox*>(ptr)->QSpinBox::heightForWidth(w);
}

void QSpinBox_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "hide");
}

void QSpinBox_HideDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::hide();
}

void QSpinBox_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QSpinBox_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QSpinBox_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "lower");
}

void QSpinBox_LowerDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::lower();
}

void QSpinBox_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QSpinBox_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QSpinBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QSpinBox*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QSpinBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QSpinBox*>(ptr)->QSpinBox::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QSpinBox_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "raise");
}

void QSpinBox_RaiseDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::raise();
}

void QSpinBox_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "repaint");
}

void QSpinBox_RepaintDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::repaint();
}

void QSpinBox_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QSpinBox_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::setDisabled(disable != 0);
}

void QSpinBox_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setFocus");
}

void QSpinBox_SetFocus2Default(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::setFocus();
}

void QSpinBox_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QSpinBox_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::setHidden(hidden != 0);
}

void QSpinBox_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "show");
}

void QSpinBox_ShowDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::show();
}

void QSpinBox_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "showFullScreen");
}

void QSpinBox_ShowFullScreenDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::showFullScreen();
}

void QSpinBox_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "showMaximized");
}

void QSpinBox_ShowMaximizedDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::showMaximized();
}

void QSpinBox_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "showMinimized");
}

void QSpinBox_ShowMinimizedDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::showMinimized();
}

void QSpinBox_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "showNormal");
}

void QSpinBox_ShowNormalDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::showNormal();
}

void QSpinBox_TabletEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QSpinBox_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QSpinBox_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "update");
}

void QSpinBox_UpdateDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::update();
}

void QSpinBox_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "updateMicroFocus");
}

void QSpinBox_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::updateMicroFocus();
}

void QSpinBox_ChildEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QSpinBox_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::childEvent(static_cast<QChildEvent*>(event));
}

void QSpinBox_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QSpinBox*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSpinBox_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSpinBox_CustomEvent(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QSpinBox_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::customEvent(static_cast<QEvent*>(event));
}

void QSpinBox_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "deleteLater");
}

void QSpinBox_DeleteLaterDefault(void* ptr)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::deleteLater();
}

void QSpinBox_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QSpinBox*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSpinBox_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSpinBox*>(ptr)->QSpinBox::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QSpinBox_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QSpinBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QSpinBox_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QSpinBox*>(ptr)->QSpinBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QSpinBox_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSpinBox*>(ptr)->metaObject());
}

void* QSpinBox_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSpinBox*>(ptr)->QSpinBox::metaObject());
}

class MyQSplashScreen: public QSplashScreen
{
public:
	MyQSplashScreen(QWidget *parent, const QPixmap &pixmap, Qt::WindowFlags f) : QSplashScreen(parent, pixmap, f) {};
	MyQSplashScreen(const QPixmap &pixmap, Qt::WindowFlags f) : QSplashScreen(pixmap, f) {};
	void clearMessage() { callbackQSplashScreen_ClearMessage(this); };
	void drawContents(QPainter * painter) { callbackQSplashScreen_DrawContents(this, painter); };
	void Signal_MessageChanged(const QString & message) { callbackQSplashScreen_MessageChanged(this, const_cast<char*>(message.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void mousePressEvent(QMouseEvent * vqm) { callbackQSplashScreen_MousePressEvent(this, vqm); };
	void showMessage(const QString & message, int alignment, const QColor & color) { callbackQSplashScreen_ShowMessage(this, const_cast<char*>(message.toUtf8().prepend("WHITESPACE").constData()+10), alignment, const_cast<QColor*>(&color)); };
	 ~MyQSplashScreen() { callbackQSplashScreen_DestroyQSplashScreen(this); };
	void actionEvent(QActionEvent * event) { callbackQSplashScreen_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQSplashScreen_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQSplashScreen_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQSplashScreen_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQSplashScreen_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQSplashScreen_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQSplashScreen_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQSplashScreen_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQSplashScreen_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQSplashScreen_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQSplashScreen_MinimumSizeHint(const_cast<MyQSplashScreen*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQSplashScreen_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQSplashScreen_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQSplashScreen_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQSplashScreen_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQSplashScreen_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQSplashScreen_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQSplashScreen_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQSplashScreen_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQSplashScreen_SizeHint(const_cast<MyQSplashScreen*>(this))); };
	void changeEvent(QEvent * event) { callbackQSplashScreen_ChangeEvent(this, event); };
	bool close() { return callbackQSplashScreen_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQSplashScreen_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQSplashScreen_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQSplashScreen_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQSplashScreen_HasHeightForWidth(const_cast<MyQSplashScreen*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQSplashScreen_HeightForWidth(const_cast<MyQSplashScreen*>(this), w); };
	void hide() { callbackQSplashScreen_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQSplashScreen_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQSplashScreen_InputMethodQuery(const_cast<MyQSplashScreen*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQSplashScreen_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQSplashScreen_KeyReleaseEvent(this, event); };
	void lower() { callbackQSplashScreen_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQSplashScreen_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQSplashScreen_MouseMoveEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQSplashScreen_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQSplashScreen_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQSplashScreen_Raise(this); };
	void resizeEvent(QResizeEvent * event) { callbackQSplashScreen_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQSplashScreen_SetDisabled(this, disable); };
	void setFocus() { callbackQSplashScreen_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQSplashScreen_SetHidden(this, hidden); };
	void show() { callbackQSplashScreen_Show(this); };
	void showFullScreen() { callbackQSplashScreen_ShowFullScreen(this); };
	void showMaximized() { callbackQSplashScreen_ShowMaximized(this); };
	void showMinimized() { callbackQSplashScreen_ShowMinimized(this); };
	void showNormal() { callbackQSplashScreen_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQSplashScreen_TabletEvent(this, event); };
	void update() { callbackQSplashScreen_Update(this); };
	void updateMicroFocus() { callbackQSplashScreen_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQSplashScreen_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQSplashScreen_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQSplashScreen_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQSplashScreen_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQSplashScreen_CustomEvent(this, event); };
	void deleteLater() { callbackQSplashScreen_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQSplashScreen_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSplashScreen_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSplashScreen_MetaObject(const_cast<MyQSplashScreen*>(this))); };
};

void* QSplashScreen_NewQSplashScreen2(void* parent, void* pixmap, long long f)
{
	return new MyQSplashScreen(static_cast<QWidget*>(parent), *static_cast<QPixmap*>(pixmap), static_cast<Qt::WindowType>(f));
}

void* QSplashScreen_NewQSplashScreen(void* pixmap, long long f)
{
	return new MyQSplashScreen(*static_cast<QPixmap*>(pixmap), static_cast<Qt::WindowType>(f));
}

void QSplashScreen_ClearMessage(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "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));
}

char QSplashScreen_Event(void* ptr, void* e)
{
	return static_cast<QSplashScreen*>(ptr)->event(static_cast<QEvent*>(e));
}

void QSplashScreen_Finish(void* ptr, void* mainWin)
{
	static_cast<QSplashScreen*>(ptr)->finish(static_cast<QWidget*>(mainWin));
}

char* QSplashScreen_Message(void* ptr)
{
	return const_cast<char*>(static_cast<QSplashScreen*>(ptr)->message().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QSplashScreen_ConnectMessageChanged(void* ptr)
{
	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));
}

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, char* message)
{
	static_cast<QSplashScreen*>(ptr)->messageChanged(QString(message));
}

void QSplashScreen_MousePressEvent(void* ptr, void* vqm)
{
	static_cast<QSplashScreen*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(vqm));
}

void QSplashScreen_MousePressEventDefault(void* ptr, void* vqm)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::mousePressEvent(static_cast<QMouseEvent*>(vqm));
}

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, char* message, int alignment, void* color)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "showMessage", Q_ARG(QString, QString(message)), Q_ARG(int, alignment), Q_ARG(QColor, *static_cast<QColor*>(color)));
}

void QSplashScreen_DestroyQSplashScreen(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->~QSplashScreen();
}

void QSplashScreen_DestroyQSplashScreenDefault(void* ptr)
{

}

void QSplashScreen_ActionEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QSplashScreen_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::actionEvent(static_cast<QActionEvent*>(event));
}

void QSplashScreen_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QSplashScreen_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QSplashScreen_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QSplashScreen_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QSplashScreen_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QSplashScreen_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QSplashScreen_DropEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QSplashScreen_DropEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::dropEvent(static_cast<QDropEvent*>(event));
}

void QSplashScreen_EnterEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QSplashScreen_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::enterEvent(static_cast<QEvent*>(event));
}

void QSplashScreen_FocusInEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QSplashScreen_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QSplashScreen_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QSplashScreen_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QSplashScreen_HideEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QSplashScreen_HideEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::hideEvent(static_cast<QHideEvent*>(event));
}

void QSplashScreen_LeaveEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QSplashScreen_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::leaveEvent(static_cast<QEvent*>(event));
}

void* QSplashScreen_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSplashScreen*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSplashScreen_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSplashScreen*>(ptr)->QSplashScreen::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QSplashScreen_MoveEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QSplashScreen_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::moveEvent(static_cast<QMoveEvent*>(event));
}

void QSplashScreen_PaintEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QSplashScreen_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::paintEvent(static_cast<QPaintEvent*>(event));
}

void QSplashScreen_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QSplashScreen_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::setEnabled(vbo != 0);
}

void QSplashScreen_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QSplashScreen_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::setStyleSheet(QString(styleSheet));
}

void QSplashScreen_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QSplashScreen_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::setVisible(visible != 0);
}

void QSplashScreen_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QSplashScreen_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::setWindowModified(vbo != 0);
}

void QSplashScreen_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QSplashScreen_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::setWindowTitle(QString(vqs));
}

void QSplashScreen_ShowEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QSplashScreen_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::showEvent(static_cast<QShowEvent*>(event));
}

void* QSplashScreen_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSplashScreen*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSplashScreen_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSplashScreen*>(ptr)->QSplashScreen::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QSplashScreen_ChangeEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QSplashScreen_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::changeEvent(static_cast<QEvent*>(event));
}

char QSplashScreen_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QSplashScreen_CloseDefault(void* ptr)
{
	return static_cast<QSplashScreen*>(ptr)->QSplashScreen::close();
}

void QSplashScreen_CloseEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QSplashScreen_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::closeEvent(static_cast<QCloseEvent*>(event));
}

void QSplashScreen_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QSplashScreen_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QSplashScreen_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QSplashScreen*>(ptr)->focusNextPrevChild(next != 0);
}

char QSplashScreen_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QSplashScreen*>(ptr)->QSplashScreen::focusNextPrevChild(next != 0);
}

char QSplashScreen_HasHeightForWidth(void* ptr)
{
	return static_cast<QSplashScreen*>(ptr)->hasHeightForWidth();
}

char QSplashScreen_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QSplashScreen*>(ptr)->QSplashScreen::hasHeightForWidth();
}

int QSplashScreen_HeightForWidth(void* ptr, int w)
{
	return static_cast<QSplashScreen*>(ptr)->heightForWidth(w);
}

int QSplashScreen_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QSplashScreen*>(ptr)->QSplashScreen::heightForWidth(w);
}

void QSplashScreen_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "hide");
}

void QSplashScreen_HideDefault(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::hide();
}

void QSplashScreen_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QSplashScreen_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QSplashScreen_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QSplashScreen*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QSplashScreen_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QSplashScreen*>(ptr)->QSplashScreen::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QSplashScreen_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QSplashScreen_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QSplashScreen_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QSplashScreen_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QSplashScreen_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "lower");
}

void QSplashScreen_LowerDefault(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::lower();
}

void QSplashScreen_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QSplashScreen_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QSplashScreen_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QSplashScreen_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QSplashScreen_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QSplashScreen_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QSplashScreen_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QSplashScreen*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QSplashScreen_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QSplashScreen*>(ptr)->QSplashScreen::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QSplashScreen_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "raise");
}

void QSplashScreen_RaiseDefault(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::raise();
}

void QSplashScreen_ResizeEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QSplashScreen_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QSplashScreen_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QSplashScreen_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::setDisabled(disable != 0);
}

void QSplashScreen_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "setFocus");
}

void QSplashScreen_SetFocus2Default(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::setFocus();
}

void QSplashScreen_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QSplashScreen_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::setHidden(hidden != 0);
}

void QSplashScreen_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "show");
}

void QSplashScreen_ShowDefault(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::show();
}

void QSplashScreen_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "showFullScreen");
}

void QSplashScreen_ShowFullScreenDefault(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::showFullScreen();
}

void QSplashScreen_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "showMaximized");
}

void QSplashScreen_ShowMaximizedDefault(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::showMaximized();
}

void QSplashScreen_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "showMinimized");
}

void QSplashScreen_ShowMinimizedDefault(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::showMinimized();
}

void QSplashScreen_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "showNormal");
}

void QSplashScreen_ShowNormalDefault(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::showNormal();
}

void QSplashScreen_TabletEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QSplashScreen_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QSplashScreen_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "update");
}

void QSplashScreen_UpdateDefault(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::update();
}

void QSplashScreen_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "updateMicroFocus");
}

void QSplashScreen_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::updateMicroFocus();
}

void QSplashScreen_WheelEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QSplashScreen_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QSplashScreen_TimerEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QSplashScreen_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::timerEvent(static_cast<QTimerEvent*>(event));
}

void QSplashScreen_ChildEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QSplashScreen_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::childEvent(static_cast<QChildEvent*>(event));
}

void QSplashScreen_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QSplashScreen*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSplashScreen_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSplashScreen_CustomEvent(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QSplashScreen_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::customEvent(static_cast<QEvent*>(event));
}

void QSplashScreen_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "deleteLater");
}

void QSplashScreen_DeleteLaterDefault(void* ptr)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::deleteLater();
}

void QSplashScreen_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QSplashScreen*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSplashScreen_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSplashScreen*>(ptr)->QSplashScreen::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QSplashScreen_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QSplashScreen*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QSplashScreen_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QSplashScreen*>(ptr)->QSplashScreen::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QSplashScreen_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSplashScreen*>(ptr)->metaObject());
}

void* QSplashScreen_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSplashScreen*>(ptr)->QSplashScreen::metaObject());
}

class MyQSplitter: public QSplitter
{
public:
	MyQSplitter(QWidget *parent) : QSplitter(parent) {};
	MyQSplitter(Qt::Orientation orientation, QWidget *parent) : QSplitter(orientation, parent) {};
	void changeEvent(QEvent * ev) { callbackQSplitter_ChangeEvent(this, ev); };
	QSplitterHandle * createHandle() { return static_cast<QSplitterHandle*>(callbackQSplitter_CreateHandle(this)); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQSplitter_MinimumSizeHint(const_cast<MyQSplitter*>(this))); };
	void resizeEvent(QResizeEvent * vqr) { callbackQSplitter_ResizeEvent(this, vqr); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQSplitter_SizeHint(const_cast<MyQSplitter*>(this))); };
	void Signal_SplitterMoved(int pos, int index) { callbackQSplitter_SplitterMoved(this, pos, index); };
	void paintEvent(QPaintEvent * vqp) { callbackQSplitter_PaintEvent(this, vqp); };
	void actionEvent(QActionEvent * event) { callbackQSplitter_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQSplitter_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQSplitter_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQSplitter_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQSplitter_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQSplitter_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQSplitter_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQSplitter_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQSplitter_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQSplitter_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQSplitter_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQSplitter_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQSplitter_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQSplitter_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQSplitter_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQSplitter_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQSplitter_ShowEvent(this, event); };
	bool close() { return callbackQSplitter_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQSplitter_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQSplitter_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQSplitter_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQSplitter_HasHeightForWidth(const_cast<MyQSplitter*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQSplitter_HeightForWidth(const_cast<MyQSplitter*>(this), w); };
	void hide() { callbackQSplitter_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQSplitter_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQSplitter_InputMethodQuery(const_cast<MyQSplitter*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQSplitter_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQSplitter_KeyReleaseEvent(this, event); };
	void lower() { callbackQSplitter_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQSplitter_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQSplitter_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQSplitter_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQSplitter_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQSplitter_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQSplitter_Raise(this); };
	void repaint() { callbackQSplitter_Repaint(this); };
	void setDisabled(bool disable) { callbackQSplitter_SetDisabled(this, disable); };
	void setFocus() { callbackQSplitter_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQSplitter_SetHidden(this, hidden); };
	void show() { callbackQSplitter_Show(this); };
	void showFullScreen() { callbackQSplitter_ShowFullScreen(this); };
	void showMaximized() { callbackQSplitter_ShowMaximized(this); };
	void showMinimized() { callbackQSplitter_ShowMinimized(this); };
	void showNormal() { callbackQSplitter_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQSplitter_TabletEvent(this, event); };
	void update() { callbackQSplitter_Update(this); };
	void updateMicroFocus() { callbackQSplitter_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQSplitter_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQSplitter_TimerEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQSplitter_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQSplitter_CustomEvent(this, event); };
	void deleteLater() { callbackQSplitter_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQSplitter_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSplitter_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSplitter_MetaObject(const_cast<MyQSplitter*>(this))); };
};

char QSplitter_ChildrenCollapsible(void* ptr)
{
	return static_cast<QSplitter*>(ptr)->childrenCollapsible();
}

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));
}

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_SetChildrenCollapsible(void* ptr, char vbo)
{
	static_cast<QSplitter*>(ptr)->setChildrenCollapsible(vbo != 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_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));
}

void QSplitter_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QSplitter*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QSplitter_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QSplitter*>(ptr)->QSplitter::changeEvent(static_cast<QEvent*>(ev));
}

void QSplitter_ChildEvent(void* ptr, void* c)
{
	static_cast<QSplitter*>(ptr)->childEvent(static_cast<QChildEvent*>(c));
}

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();
}

char QSplitter_Event(void* ptr, void* e)
{
	return static_cast<QSplitter*>(ptr)->event(static_cast<QEvent*>(e));
}

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);
}

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_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSplitter*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSplitter_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSplitter*>(ptr)->QSplitter::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QSplitter_MoveSplitter(void* ptr, int pos, int index)
{
	static_cast<QSplitter*>(ptr)->moveSplitter(pos, index);
}

void QSplitter_Refresh(void* ptr)
{
	static_cast<QSplitter*>(ptr)->refresh();
}

void QSplitter_ResizeEvent(void* ptr, void* vqr)
{
	static_cast<QSplitter*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QSplitter_ResizeEventDefault(void* ptr, void* vqr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::resizeEvent(static_cast<QResizeEvent*>(vqr));
}

char QSplitter_RestoreState(void* ptr, char* state)
{
	return static_cast<QSplitter*>(ptr)->restoreState(QByteArray::fromHex(QString(state).toUtf8()));
}

char* QSplitter_SaveState(void* ptr)
{
	return const_cast<char*>(static_cast<QSplitter*>(ptr)->saveState().toHex().prepend("WHITESPACE").constData()+10);
}

void QSplitter_SetCollapsible(void* ptr, int index, char collapse)
{
	static_cast<QSplitter*>(ptr)->setCollapsible(index, collapse != 0);
}

void QSplitter_SetRubberBand(void* ptr, int pos)
{
	static_cast<QSplitter*>(ptr)->setRubberBand(pos);
}

void QSplitter_SetStretchFactor(void* ptr, int index, int stretch)
{
	static_cast<QSplitter*>(ptr)->setStretchFactor(index, stretch);
}

void* QSplitter_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSplitter*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSplitter_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSplitter*>(ptr)->QSplitter::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QSplitter_ConnectSplitterMoved(void* ptr)
{
	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));
}

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_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QSplitter*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QSplitter_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QSplitter*>(ptr)->QSplitter::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QSplitter_ActionEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QSplitter_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::actionEvent(static_cast<QActionEvent*>(event));
}

void QSplitter_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QSplitter_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QSplitter_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QSplitter_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QSplitter_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QSplitter_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QSplitter_DropEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QSplitter_DropEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::dropEvent(static_cast<QDropEvent*>(event));
}

void QSplitter_EnterEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QSplitter_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::enterEvent(static_cast<QEvent*>(event));
}

void QSplitter_FocusInEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QSplitter_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QSplitter_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QSplitter_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QSplitter_HideEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QSplitter_HideEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::hideEvent(static_cast<QHideEvent*>(event));
}

void QSplitter_LeaveEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QSplitter_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::leaveEvent(static_cast<QEvent*>(event));
}

void QSplitter_MoveEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QSplitter_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::moveEvent(static_cast<QMoveEvent*>(event));
}

void QSplitter_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QSplitter_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QSplitter*>(ptr)->QSplitter::setEnabled(vbo != 0);
}

void QSplitter_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QSplitter_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QSplitter*>(ptr)->QSplitter::setStyleSheet(QString(styleSheet));
}

void QSplitter_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QSplitter_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QSplitter*>(ptr)->QSplitter::setVisible(visible != 0);
}

void QSplitter_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QSplitter_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QSplitter*>(ptr)->QSplitter::setWindowModified(vbo != 0);
}

void QSplitter_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QSplitter_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QSplitter*>(ptr)->QSplitter::setWindowTitle(QString(vqs));
}

void QSplitter_ShowEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QSplitter_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::showEvent(static_cast<QShowEvent*>(event));
}

char QSplitter_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QSplitter_CloseDefault(void* ptr)
{
	return static_cast<QSplitter*>(ptr)->QSplitter::close();
}

void QSplitter_CloseEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QSplitter_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::closeEvent(static_cast<QCloseEvent*>(event));
}

void QSplitter_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QSplitter_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QSplitter_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QSplitter*>(ptr)->focusNextPrevChild(next != 0);
}

char QSplitter_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QSplitter*>(ptr)->QSplitter::focusNextPrevChild(next != 0);
}

char QSplitter_HasHeightForWidth(void* ptr)
{
	return static_cast<QSplitter*>(ptr)->hasHeightForWidth();
}

char QSplitter_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QSplitter*>(ptr)->QSplitter::hasHeightForWidth();
}

int QSplitter_HeightForWidth(void* ptr, int w)
{
	return static_cast<QSplitter*>(ptr)->heightForWidth(w);
}

int QSplitter_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QSplitter*>(ptr)->QSplitter::heightForWidth(w);
}

void QSplitter_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "hide");
}

void QSplitter_HideDefault(void* ptr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::hide();
}

void QSplitter_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QSplitter_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QSplitter_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QSplitter*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QSplitter_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QSplitter*>(ptr)->QSplitter::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QSplitter_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QSplitter_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QSplitter_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QSplitter_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QSplitter_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "lower");
}

void QSplitter_LowerDefault(void* ptr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::lower();
}

void QSplitter_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QSplitter_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QSplitter_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QSplitter_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QSplitter_MousePressEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QSplitter_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QSplitter_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QSplitter_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QSplitter_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QSplitter*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QSplitter_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QSplitter*>(ptr)->QSplitter::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QSplitter_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "raise");
}

void QSplitter_RaiseDefault(void* ptr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::raise();
}

void QSplitter_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "repaint");
}

void QSplitter_RepaintDefault(void* ptr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::repaint();
}

void QSplitter_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QSplitter_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QSplitter*>(ptr)->QSplitter::setDisabled(disable != 0);
}

void QSplitter_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "setFocus");
}

void QSplitter_SetFocus2Default(void* ptr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::setFocus();
}

void QSplitter_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QSplitter_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QSplitter*>(ptr)->QSplitter::setHidden(hidden != 0);
}

void QSplitter_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "show");
}

void QSplitter_ShowDefault(void* ptr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::show();
}

void QSplitter_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "showFullScreen");
}

void QSplitter_ShowFullScreenDefault(void* ptr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::showFullScreen();
}

void QSplitter_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "showMaximized");
}

void QSplitter_ShowMaximizedDefault(void* ptr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::showMaximized();
}

void QSplitter_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "showMinimized");
}

void QSplitter_ShowMinimizedDefault(void* ptr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::showMinimized();
}

void QSplitter_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "showNormal");
}

void QSplitter_ShowNormalDefault(void* ptr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::showNormal();
}

void QSplitter_TabletEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QSplitter_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QSplitter_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "update");
}

void QSplitter_UpdateDefault(void* ptr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::update();
}

void QSplitter_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "updateMicroFocus");
}

void QSplitter_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::updateMicroFocus();
}

void QSplitter_WheelEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QSplitter_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QSplitter_TimerEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QSplitter_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::timerEvent(static_cast<QTimerEvent*>(event));
}

void QSplitter_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QSplitter*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSplitter_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSplitter*>(ptr)->QSplitter::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSplitter_CustomEvent(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QSplitter_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QSplitter*>(ptr)->QSplitter::customEvent(static_cast<QEvent*>(event));
}

void QSplitter_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "deleteLater");
}

void QSplitter_DeleteLaterDefault(void* ptr)
{
	static_cast<QSplitter*>(ptr)->QSplitter::deleteLater();
}

void QSplitter_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QSplitter*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSplitter_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSplitter*>(ptr)->QSplitter::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QSplitter_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QSplitter*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QSplitter_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QSplitter*>(ptr)->QSplitter::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QSplitter_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSplitter*>(ptr)->metaObject());
}

void* QSplitter_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSplitter*>(ptr)->QSplitter::metaObject());
}

class MyQSplitterHandle: public QSplitterHandle
{
public:
	MyQSplitterHandle(Qt::Orientation orientation, QSplitter *parent) : QSplitterHandle(orientation, parent) {};
	void mouseMoveEvent(QMouseEvent * e) { callbackQSplitterHandle_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQSplitterHandle_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQSplitterHandle_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * vqp) { callbackQSplitterHandle_PaintEvent(this, vqp); };
	void resizeEvent(QResizeEvent * event) { callbackQSplitterHandle_ResizeEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQSplitterHandle_SizeHint(const_cast<MyQSplitterHandle*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQSplitterHandle_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQSplitterHandle_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQSplitterHandle_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQSplitterHandle_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQSplitterHandle_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQSplitterHandle_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQSplitterHandle_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQSplitterHandle_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQSplitterHandle_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQSplitterHandle_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQSplitterHandle_MinimumSizeHint(const_cast<MyQSplitterHandle*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQSplitterHandle_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQSplitterHandle_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQSplitterHandle_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQSplitterHandle_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQSplitterHandle_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQSplitterHandle_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQSplitterHandle_ShowEvent(this, event); };
	void changeEvent(QEvent * event) { callbackQSplitterHandle_ChangeEvent(this, event); };
	bool close() { return callbackQSplitterHandle_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQSplitterHandle_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQSplitterHandle_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQSplitterHandle_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQSplitterHandle_HasHeightForWidth(const_cast<MyQSplitterHandle*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQSplitterHandle_HeightForWidth(const_cast<MyQSplitterHandle*>(this), w); };
	void hide() { callbackQSplitterHandle_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQSplitterHandle_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQSplitterHandle_InputMethodQuery(const_cast<MyQSplitterHandle*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQSplitterHandle_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQSplitterHandle_KeyReleaseEvent(this, event); };
	void lower() { callbackQSplitterHandle_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQSplitterHandle_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQSplitterHandle_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQSplitterHandle_Raise(this); };
	void repaint() { callbackQSplitterHandle_Repaint(this); };
	void setDisabled(bool disable) { callbackQSplitterHandle_SetDisabled(this, disable); };
	void setFocus() { callbackQSplitterHandle_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQSplitterHandle_SetHidden(this, hidden); };
	void show() { callbackQSplitterHandle_Show(this); };
	void showFullScreen() { callbackQSplitterHandle_ShowFullScreen(this); };
	void showMaximized() { callbackQSplitterHandle_ShowMaximized(this); };
	void showMinimized() { callbackQSplitterHandle_ShowMinimized(this); };
	void showNormal() { callbackQSplitterHandle_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQSplitterHandle_TabletEvent(this, event); };
	void update() { callbackQSplitterHandle_Update(this); };
	void updateMicroFocus() { callbackQSplitterHandle_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQSplitterHandle_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQSplitterHandle_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQSplitterHandle_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQSplitterHandle_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQSplitterHandle_CustomEvent(this, event); };
	void deleteLater() { callbackQSplitterHandle_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQSplitterHandle_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSplitterHandle_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSplitterHandle_MetaObject(const_cast<MyQSplitterHandle*>(this))); };
};

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);
}

char QSplitterHandle_Event(void* ptr, void* event)
{
	return static_cast<QSplitterHandle*>(ptr)->event(static_cast<QEvent*>(event));
}

void QSplitterHandle_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QSplitterHandle*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QSplitterHandle_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QSplitterHandle_MousePressEvent(void* ptr, void* e)
{
	static_cast<QSplitterHandle*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QSplitterHandle_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QSplitterHandle_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QSplitterHandle*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QSplitterHandle_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

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_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QSplitterHandle*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QSplitterHandle_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QSplitterHandle_ResizeEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QSplitterHandle_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QSplitterHandle_SetOrientation(void* ptr, long long orientation)
{
	static_cast<QSplitterHandle*>(ptr)->setOrientation(static_cast<Qt::Orientation>(orientation));
}

void* QSplitterHandle_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSplitterHandle*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSplitterHandle_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSplitterHandle_Splitter(void* ptr)
{
	return static_cast<QSplitterHandle*>(ptr)->splitter();
}

void QSplitterHandle_DestroyQSplitterHandle(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->~QSplitterHandle();
}

void QSplitterHandle_ActionEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QSplitterHandle_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::actionEvent(static_cast<QActionEvent*>(event));
}

void QSplitterHandle_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QSplitterHandle_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QSplitterHandle_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QSplitterHandle_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QSplitterHandle_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QSplitterHandle_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QSplitterHandle_DropEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QSplitterHandle_DropEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::dropEvent(static_cast<QDropEvent*>(event));
}

void QSplitterHandle_EnterEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QSplitterHandle_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::enterEvent(static_cast<QEvent*>(event));
}

void QSplitterHandle_FocusInEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QSplitterHandle_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QSplitterHandle_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QSplitterHandle_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QSplitterHandle_HideEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QSplitterHandle_HideEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::hideEvent(static_cast<QHideEvent*>(event));
}

void QSplitterHandle_LeaveEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QSplitterHandle_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::leaveEvent(static_cast<QEvent*>(event));
}

void* QSplitterHandle_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSplitterHandle*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QSplitterHandle_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QSplitterHandle_MoveEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QSplitterHandle_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::moveEvent(static_cast<QMoveEvent*>(event));
}

void QSplitterHandle_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QSplitterHandle_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setEnabled(vbo != 0);
}

void QSplitterHandle_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QSplitterHandle_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setStyleSheet(QString(styleSheet));
}

void QSplitterHandle_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QSplitterHandle_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setVisible(visible != 0);
}

void QSplitterHandle_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QSplitterHandle_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setWindowModified(vbo != 0);
}

void QSplitterHandle_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QSplitterHandle_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setWindowTitle(QString(vqs));
}

void QSplitterHandle_ShowEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QSplitterHandle_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::showEvent(static_cast<QShowEvent*>(event));
}

void QSplitterHandle_ChangeEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QSplitterHandle_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::changeEvent(static_cast<QEvent*>(event));
}

char QSplitterHandle_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QSplitterHandle_CloseDefault(void* ptr)
{
	return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::close();
}

void QSplitterHandle_CloseEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QSplitterHandle_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::closeEvent(static_cast<QCloseEvent*>(event));
}

void QSplitterHandle_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QSplitterHandle_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QSplitterHandle_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QSplitterHandle*>(ptr)->focusNextPrevChild(next != 0);
}

char QSplitterHandle_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::focusNextPrevChild(next != 0);
}

char QSplitterHandle_HasHeightForWidth(void* ptr)
{
	return static_cast<QSplitterHandle*>(ptr)->hasHeightForWidth();
}

char QSplitterHandle_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::hasHeightForWidth();
}

int QSplitterHandle_HeightForWidth(void* ptr, int w)
{
	return static_cast<QSplitterHandle*>(ptr)->heightForWidth(w);
}

int QSplitterHandle_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::heightForWidth(w);
}

void QSplitterHandle_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "hide");
}

void QSplitterHandle_HideDefault(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::hide();
}

void QSplitterHandle_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QSplitterHandle_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QSplitterHandle_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QSplitterHandle*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QSplitterHandle_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QSplitterHandle_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QSplitterHandle_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QSplitterHandle_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QSplitterHandle_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QSplitterHandle_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "lower");
}

void QSplitterHandle_LowerDefault(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::lower();
}

void QSplitterHandle_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QSplitterHandle_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QSplitterHandle_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QSplitterHandle*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QSplitterHandle_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QSplitterHandle_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "raise");
}

void QSplitterHandle_RaiseDefault(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::raise();
}

void QSplitterHandle_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "repaint");
}

void QSplitterHandle_RepaintDefault(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::repaint();
}

void QSplitterHandle_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QSplitterHandle_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setDisabled(disable != 0);
}

void QSplitterHandle_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "setFocus");
}

void QSplitterHandle_SetFocus2Default(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setFocus();
}

void QSplitterHandle_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QSplitterHandle_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setHidden(hidden != 0);
}

void QSplitterHandle_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "show");
}

void QSplitterHandle_ShowDefault(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::show();
}

void QSplitterHandle_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "showFullScreen");
}

void QSplitterHandle_ShowFullScreenDefault(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::showFullScreen();
}

void QSplitterHandle_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "showMaximized");
}

void QSplitterHandle_ShowMaximizedDefault(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::showMaximized();
}

void QSplitterHandle_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "showMinimized");
}

void QSplitterHandle_ShowMinimizedDefault(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::showMinimized();
}

void QSplitterHandle_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "showNormal");
}

void QSplitterHandle_ShowNormalDefault(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::showNormal();
}

void QSplitterHandle_TabletEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QSplitterHandle_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QSplitterHandle_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "update");
}

void QSplitterHandle_UpdateDefault(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::update();
}

void QSplitterHandle_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "updateMicroFocus");
}

void QSplitterHandle_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::updateMicroFocus();
}

void QSplitterHandle_WheelEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QSplitterHandle_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QSplitterHandle_TimerEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QSplitterHandle_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::timerEvent(static_cast<QTimerEvent*>(event));
}

void QSplitterHandle_ChildEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QSplitterHandle_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::childEvent(static_cast<QChildEvent*>(event));
}

void QSplitterHandle_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QSplitterHandle*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSplitterHandle_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSplitterHandle_CustomEvent(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QSplitterHandle_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::customEvent(static_cast<QEvent*>(event));
}

void QSplitterHandle_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "deleteLater");
}

void QSplitterHandle_DeleteLaterDefault(void* ptr)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::deleteLater();
}

void QSplitterHandle_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QSplitterHandle*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSplitterHandle_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QSplitterHandle_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QSplitterHandle*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QSplitterHandle_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QSplitterHandle_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSplitterHandle*>(ptr)->metaObject());
}

void* QSplitterHandle_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::metaObject());
}

class MyQStackedLayout: public QStackedLayout
{
public:
	MyQStackedLayout() : QStackedLayout() {};
	MyQStackedLayout(QLayout *parentLayout) : QStackedLayout(parentLayout) {};
	MyQStackedLayout(QWidget *parent) : QStackedLayout(parent) {};
	int count() const { return callbackQStackedLayout_Count(const_cast<MyQStackedLayout*>(this)); };
	void setCurrentIndex(int index) { callbackQStackedLayout_SetCurrentIndex(this, index); };
	void setCurrentWidget(QWidget * widget) { callbackQStackedLayout_SetCurrentWidget(this, widget); };
	void addItem(QLayoutItem * item) { callbackQStackedLayout_AddItem(this, item); };
	void Signal_CurrentChanged(int index) { callbackQStackedLayout_CurrentChanged(this, index); };
	bool hasHeightForWidth() const { return callbackQStackedLayout_HasHeightForWidth(const_cast<MyQStackedLayout*>(this)) != 0; };
	int heightForWidth(int width) const { return callbackQStackedLayout_HeightForWidth(const_cast<MyQStackedLayout*>(this), width); };
	QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQStackedLayout_ItemAt(const_cast<MyQStackedLayout*>(this), index)); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQStackedLayout_MinimumSize(const_cast<MyQStackedLayout*>(this))); };
	void setGeometry(const QRect & rect) { callbackQStackedLayout_SetGeometry(this, const_cast<QRect*>(&rect)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQStackedLayout_SizeHint(const_cast<MyQStackedLayout*>(this))); };
	QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQStackedLayout_TakeAt(this, index)); };
	void Signal_WidgetRemoved(int index) { callbackQStackedLayout_WidgetRemoved(this, index); };
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQStackedLayout_ControlTypes(const_cast<MyQStackedLayout*>(this))); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQStackedLayout_ExpandingDirections(const_cast<MyQStackedLayout*>(this))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQStackedLayout_Geometry(const_cast<MyQStackedLayout*>(this))); };
	int indexOf(QWidget * widget) const { return callbackQStackedLayout_IndexOf(const_cast<MyQStackedLayout*>(this), widget); };
	void invalidate() { callbackQStackedLayout_Invalidate(this); };
	bool isEmpty() const { return callbackQStackedLayout_IsEmpty(const_cast<MyQStackedLayout*>(this)) != 0; };
	QLayout * layout() { return static_cast<QLayout*>(callbackQStackedLayout_Layout(this)); };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQStackedLayout_MaximumSize(const_cast<MyQStackedLayout*>(this))); };
	void timerEvent(QTimerEvent * event) { callbackQStackedLayout_TimerEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQStackedLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQStackedLayout_CustomEvent(this, event); };
	void deleteLater() { callbackQStackedLayout_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQStackedLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQStackedLayout_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQStackedLayout_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStackedLayout_MetaObject(const_cast<MyQStackedLayout*>(this))); };
	int minimumHeightForWidth(int w) const { return callbackQStackedLayout_MinimumHeightForWidth(const_cast<MyQStackedLayout*>(this), w); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQStackedLayout_SpacerItem(this)); };
};

int QStackedLayout_Count(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->count();
}

int QStackedLayout_CountDefault(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->QStackedLayout::count();
}

int QStackedLayout_CurrentIndex(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->currentIndex();
}

void QStackedLayout_SetCurrentIndex(void* ptr, int index)
{
	QMetaObject::invokeMethod(static_cast<QStackedLayout*>(ptr), "setCurrentIndex", Q_ARG(int, index));
}

void QStackedLayout_SetCurrentWidget(void* ptr, void* widget)
{
	QMetaObject::invokeMethod(static_cast<QStackedLayout*>(ptr), "setCurrentWidget", Q_ARG(QWidget*, static_cast<QWidget*>(widget)));
}

void QStackedLayout_SetStackingMode(void* ptr, long long stackingMode)
{
	static_cast<QStackedLayout*>(ptr)->setStackingMode(static_cast<QStackedLayout::StackingMode>(stackingMode));
}

long long QStackedLayout_StackingMode(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->stackingMode();
}

void* QStackedLayout_NewQStackedLayout()
{
	return new MyQStackedLayout();
}

void* QStackedLayout_NewQStackedLayout3(void* parentLayout)
{
	return new MyQStackedLayout(static_cast<QLayout*>(parentLayout));
}

void* QStackedLayout_NewQStackedLayout2(void* parent)
{
	return new MyQStackedLayout(static_cast<QWidget*>(parent));
}

void QStackedLayout_AddItem(void* ptr, void* item)
{
	static_cast<QStackedLayout*>(ptr)->addItem(static_cast<QLayoutItem*>(item));
}

void QStackedLayout_AddItemDefault(void* ptr, void* item)
{
	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));
}

void QStackedLayout_ConnectCurrentChanged(void* ptr)
{
	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));
}

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);
}

void* QStackedLayout_CurrentWidget(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->currentWidget();
}

char QStackedLayout_HasHeightForWidth(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->hasHeightForWidth();
}

char QStackedLayout_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->QStackedLayout::hasHeightForWidth();
}

int QStackedLayout_HeightForWidth(void* ptr, int width)
{
	return static_cast<QStackedLayout*>(ptr)->heightForWidth(width);
}

int QStackedLayout_HeightForWidthDefault(void* ptr, int width)
{
	return static_cast<QStackedLayout*>(ptr)->QStackedLayout::heightForWidth(width);
}

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_MinimumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStackedLayout*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QStackedLayout_MinimumSizeDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStackedLayout*>(ptr)->QStackedLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStackedLayout_SetGeometry(void* ptr, void* rect)
{
	static_cast<QStackedLayout*>(ptr)->setGeometry(*static_cast<QRect*>(rect));
}

void QStackedLayout_SetGeometryDefault(void* ptr, void* rect)
{
	static_cast<QStackedLayout*>(ptr)->QStackedLayout::setGeometry(*static_cast<QRect*>(rect));
}

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()); });
}

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)
{
	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));
}

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();
}

long long QStackedLayout_ControlTypes(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->controlTypes();
}

long long QStackedLayout_ControlTypesDefault(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->QStackedLayout::controlTypes();
}

long long QStackedLayout_ExpandingDirections(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->expandingDirections();
}

long long QStackedLayout_ExpandingDirectionsDefault(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->QStackedLayout::expandingDirections();
}

void* QStackedLayout_Geometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QStackedLayout*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QStackedLayout_GeometryDefault(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QStackedLayout*>(ptr)->QStackedLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

int QStackedLayout_IndexOf(void* ptr, void* widget)
{
	return static_cast<QStackedLayout*>(ptr)->indexOf(static_cast<QWidget*>(widget));
}

int QStackedLayout_IndexOfDefault(void* ptr, void* widget)
{
	return static_cast<QStackedLayout*>(ptr)->QStackedLayout::indexOf(static_cast<QWidget*>(widget));
}

void QStackedLayout_Invalidate(void* ptr)
{
	static_cast<QStackedLayout*>(ptr)->invalidate();
}

void QStackedLayout_InvalidateDefault(void* ptr)
{
	static_cast<QStackedLayout*>(ptr)->QStackedLayout::invalidate();
}

char QStackedLayout_IsEmpty(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->isEmpty();
}

char QStackedLayout_IsEmptyDefault(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->QStackedLayout::isEmpty();
}

void* QStackedLayout_Layout(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->layout();
}

void* QStackedLayout_LayoutDefault(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->QStackedLayout::layout();
}

void* QStackedLayout_MaximumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStackedLayout*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QStackedLayout_MaximumSizeDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStackedLayout*>(ptr)->QStackedLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStackedLayout_TimerEvent(void* ptr, void* event)
{
	static_cast<QStackedLayout*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QStackedLayout_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QStackedLayout*>(ptr)->QStackedLayout::timerEvent(static_cast<QTimerEvent*>(event));
}

void QStackedLayout_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QStackedLayout*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStackedLayout_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QStackedLayout*>(ptr)->QStackedLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStackedLayout_CustomEvent(void* ptr, void* event)
{
	static_cast<QStackedLayout*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QStackedLayout_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QStackedLayout*>(ptr)->QStackedLayout::customEvent(static_cast<QEvent*>(event));
}

void QStackedLayout_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedLayout*>(ptr), "deleteLater");
}

void QStackedLayout_DeleteLaterDefault(void* ptr)
{
	static_cast<QStackedLayout*>(ptr)->QStackedLayout::deleteLater();
}

void QStackedLayout_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QStackedLayout*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStackedLayout_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QStackedLayout*>(ptr)->QStackedLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QStackedLayout_Event(void* ptr, void* e)
{
	return static_cast<QStackedLayout*>(ptr)->event(static_cast<QEvent*>(e));
}

char QStackedLayout_EventDefault(void* ptr, void* e)
{
	return static_cast<QStackedLayout*>(ptr)->QStackedLayout::event(static_cast<QEvent*>(e));
}

char QStackedLayout_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QStackedLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QStackedLayout_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QStackedLayout*>(ptr)->QStackedLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QStackedLayout_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QStackedLayout*>(ptr)->metaObject());
}

void* QStackedLayout_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QStackedLayout*>(ptr)->QStackedLayout::metaObject());
}

int QStackedLayout_MinimumHeightForWidth(void* ptr, int w)
{
	return static_cast<QStackedLayout*>(ptr)->minimumHeightForWidth(w);
}

int QStackedLayout_MinimumHeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QStackedLayout*>(ptr)->QStackedLayout::minimumHeightForWidth(w);
}

void* QStackedLayout_SpacerItem(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->spacerItem();
}

void* QStackedLayout_SpacerItemDefault(void* ptr)
{
	return static_cast<QStackedLayout*>(ptr)->QStackedLayout::spacerItem();
}

class MyQStackedWidget: public QStackedWidget
{
public:
	MyQStackedWidget(QWidget *parent) : QStackedWidget(parent) {};
	void setCurrentIndex(int index) { callbackQStackedWidget_SetCurrentIndex(this, index); };
	void setCurrentWidget(QWidget * widget) { callbackQStackedWidget_SetCurrentWidget(this, widget); };
	void Signal_CurrentChanged(int index) { callbackQStackedWidget_CurrentChanged(this, index); };
	void Signal_WidgetRemoved(int index) { callbackQStackedWidget_WidgetRemoved(this, index); };
	void changeEvent(QEvent * ev) { callbackQStackedWidget_ChangeEvent(this, ev); };
	void paintEvent(QPaintEvent * vqp) { callbackQStackedWidget_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQStackedWidget_SizeHint(const_cast<MyQStackedWidget*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQStackedWidget_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQStackedWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQStackedWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQStackedWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQStackedWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQStackedWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQStackedWidget_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQStackedWidget_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQStackedWidget_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQStackedWidget_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQStackedWidget_MinimumSizeHint(const_cast<MyQStackedWidget*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQStackedWidget_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQStackedWidget_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQStackedWidget_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQStackedWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQStackedWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQStackedWidget_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQStackedWidget_ShowEvent(this, event); };
	bool close() { return callbackQStackedWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQStackedWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQStackedWidget_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQStackedWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQStackedWidget_HasHeightForWidth(const_cast<MyQStackedWidget*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQStackedWidget_HeightForWidth(const_cast<MyQStackedWidget*>(this), w); };
	void hide() { callbackQStackedWidget_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQStackedWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQStackedWidget_InputMethodQuery(const_cast<MyQStackedWidget*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQStackedWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQStackedWidget_KeyReleaseEvent(this, event); };
	void lower() { callbackQStackedWidget_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQStackedWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQStackedWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQStackedWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQStackedWidget_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQStackedWidget_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQStackedWidget_Raise(this); };
	void repaint() { callbackQStackedWidget_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQStackedWidget_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQStackedWidget_SetDisabled(this, disable); };
	void setFocus() { callbackQStackedWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQStackedWidget_SetHidden(this, hidden); };
	void show() { callbackQStackedWidget_Show(this); };
	void showFullScreen() { callbackQStackedWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQStackedWidget_ShowMaximized(this); };
	void showMinimized() { callbackQStackedWidget_ShowMinimized(this); };
	void showNormal() { callbackQStackedWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQStackedWidget_TabletEvent(this, event); };
	void update() { callbackQStackedWidget_Update(this); };
	void updateMicroFocus() { callbackQStackedWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQStackedWidget_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQStackedWidget_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQStackedWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQStackedWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQStackedWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQStackedWidget_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQStackedWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQStackedWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStackedWidget_MetaObject(const_cast<MyQStackedWidget*>(this))); };
};

int QStackedWidget_Count(void* ptr)
{
	return static_cast<QStackedWidget*>(ptr)->count();
}

int QStackedWidget_CurrentIndex(void* ptr)
{
	return static_cast<QStackedWidget*>(ptr)->currentIndex();
}

void QStackedWidget_SetCurrentIndex(void* ptr, int index)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setCurrentIndex", Q_ARG(int, index));
}

void QStackedWidget_SetCurrentWidget(void* ptr, void* widget)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setCurrentWidget", Q_ARG(QWidget*, static_cast<QWidget*>(widget)));
}

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));
}

void QStackedWidget_ConnectCurrentChanged(void* ptr)
{
	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));
}

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);
}

void* QStackedWidget_CurrentWidget(void* ptr)
{
	return static_cast<QStackedWidget*>(ptr)->currentWidget();
}

char QStackedWidget_Event(void* ptr, void* e)
{
	return static_cast<QStackedWidget*>(ptr)->event(static_cast<QEvent*>(e));
}

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_Widget(void* ptr, int index)
{
	return static_cast<QStackedWidget*>(ptr)->widget(index);
}

void QStackedWidget_ConnectWidgetRemoved(void* ptr)
{
	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));
}

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_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QStackedWidget*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QStackedWidget_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::changeEvent(static_cast<QEvent*>(ev));
}

void QStackedWidget_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QStackedWidget*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QStackedWidget_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void* QStackedWidget_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStackedWidget*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QStackedWidget_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStackedWidget*>(ptr)->QStackedWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStackedWidget_ActionEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QStackedWidget_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::actionEvent(static_cast<QActionEvent*>(event));
}

void QStackedWidget_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QStackedWidget_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QStackedWidget_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QStackedWidget_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QStackedWidget_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QStackedWidget_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QStackedWidget_DropEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QStackedWidget_DropEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::dropEvent(static_cast<QDropEvent*>(event));
}

void QStackedWidget_EnterEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QStackedWidget_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::enterEvent(static_cast<QEvent*>(event));
}

void QStackedWidget_FocusInEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QStackedWidget_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QStackedWidget_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QStackedWidget_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QStackedWidget_HideEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QStackedWidget_HideEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::hideEvent(static_cast<QHideEvent*>(event));
}

void QStackedWidget_LeaveEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QStackedWidget_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::leaveEvent(static_cast<QEvent*>(event));
}

void* QStackedWidget_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStackedWidget*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QStackedWidget_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStackedWidget*>(ptr)->QStackedWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStackedWidget_MoveEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QStackedWidget_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::moveEvent(static_cast<QMoveEvent*>(event));
}

void QStackedWidget_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QStackedWidget_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::setEnabled(vbo != 0);
}

void QStackedWidget_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QStackedWidget_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::setStyleSheet(QString(styleSheet));
}

void QStackedWidget_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QStackedWidget_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::setVisible(visible != 0);
}

void QStackedWidget_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QStackedWidget_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::setWindowModified(vbo != 0);
}

void QStackedWidget_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QStackedWidget_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::setWindowTitle(QString(vqs));
}

void QStackedWidget_ShowEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QStackedWidget_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::showEvent(static_cast<QShowEvent*>(event));
}

char QStackedWidget_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QStackedWidget_CloseDefault(void* ptr)
{
	return static_cast<QStackedWidget*>(ptr)->QStackedWidget::close();
}

void QStackedWidget_CloseEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QStackedWidget_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::closeEvent(static_cast<QCloseEvent*>(event));
}

void QStackedWidget_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QStackedWidget_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QStackedWidget_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QStackedWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QStackedWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QStackedWidget*>(ptr)->QStackedWidget::focusNextPrevChild(next != 0);
}

char QStackedWidget_HasHeightForWidth(void* ptr)
{
	return static_cast<QStackedWidget*>(ptr)->hasHeightForWidth();
}

char QStackedWidget_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QStackedWidget*>(ptr)->QStackedWidget::hasHeightForWidth();
}

int QStackedWidget_HeightForWidth(void* ptr, int w)
{
	return static_cast<QStackedWidget*>(ptr)->heightForWidth(w);
}

int QStackedWidget_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QStackedWidget*>(ptr)->QStackedWidget::heightForWidth(w);
}

void QStackedWidget_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "hide");
}

void QStackedWidget_HideDefault(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::hide();
}

void QStackedWidget_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QStackedWidget_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QStackedWidget_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QStackedWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QStackedWidget_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QStackedWidget*>(ptr)->QStackedWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QStackedWidget_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QStackedWidget_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QStackedWidget_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QStackedWidget_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QStackedWidget_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "lower");
}

void QStackedWidget_LowerDefault(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::lower();
}

void QStackedWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QStackedWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QStackedWidget_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QStackedWidget_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QStackedWidget_MousePressEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QStackedWidget_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QStackedWidget_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QStackedWidget_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QStackedWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QStackedWidget*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QStackedWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QStackedWidget*>(ptr)->QStackedWidget::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QStackedWidget_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "raise");
}

void QStackedWidget_RaiseDefault(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::raise();
}

void QStackedWidget_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "repaint");
}

void QStackedWidget_RepaintDefault(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::repaint();
}

void QStackedWidget_ResizeEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QStackedWidget_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QStackedWidget_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QStackedWidget_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::setDisabled(disable != 0);
}

void QStackedWidget_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setFocus");
}

void QStackedWidget_SetFocus2Default(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::setFocus();
}

void QStackedWidget_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QStackedWidget_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::setHidden(hidden != 0);
}

void QStackedWidget_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "show");
}

void QStackedWidget_ShowDefault(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::show();
}

void QStackedWidget_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "showFullScreen");
}

void QStackedWidget_ShowFullScreenDefault(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::showFullScreen();
}

void QStackedWidget_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "showMaximized");
}

void QStackedWidget_ShowMaximizedDefault(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::showMaximized();
}

void QStackedWidget_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "showMinimized");
}

void QStackedWidget_ShowMinimizedDefault(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::showMinimized();
}

void QStackedWidget_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "showNormal");
}

void QStackedWidget_ShowNormalDefault(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::showNormal();
}

void QStackedWidget_TabletEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QStackedWidget_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QStackedWidget_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "update");
}

void QStackedWidget_UpdateDefault(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::update();
}

void QStackedWidget_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "updateMicroFocus");
}

void QStackedWidget_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::updateMicroFocus();
}

void QStackedWidget_WheelEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QStackedWidget_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QStackedWidget_TimerEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QStackedWidget_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::timerEvent(static_cast<QTimerEvent*>(event));
}

void QStackedWidget_ChildEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QStackedWidget_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::childEvent(static_cast<QChildEvent*>(event));
}

void QStackedWidget_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QStackedWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStackedWidget_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStackedWidget_CustomEvent(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QStackedWidget_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::customEvent(static_cast<QEvent*>(event));
}

void QStackedWidget_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "deleteLater");
}

void QStackedWidget_DeleteLaterDefault(void* ptr)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::deleteLater();
}

void QStackedWidget_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QStackedWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStackedWidget_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QStackedWidget*>(ptr)->QStackedWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QStackedWidget_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QStackedWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QStackedWidget_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QStackedWidget*>(ptr)->QStackedWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QStackedWidget_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QStackedWidget*>(ptr)->metaObject());
}

void* QStackedWidget_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QStackedWidget*>(ptr)->QStackedWidget::metaObject());
}

class MyQStatusBar: public QStatusBar
{
public:
	MyQStatusBar(QWidget *parent) : QStatusBar(parent) {};
	void paintEvent(QPaintEvent * event) { callbackQStatusBar_PaintEvent(this, event); };
	void clearMessage() { callbackQStatusBar_ClearMessage(this); };
	void Signal_MessageChanged(const QString & message) { callbackQStatusBar_MessageChanged(this, const_cast<char*>(message.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void resizeEvent(QResizeEvent * e) { callbackQStatusBar_ResizeEvent(this, e); };
	void showEvent(QShowEvent * vqs) { callbackQStatusBar_ShowEvent(this, vqs); };
	void showMessage(const QString & message, int timeout) { callbackQStatusBar_ShowMessage(this, const_cast<char*>(message.toUtf8().prepend("WHITESPACE").constData()+10), timeout); };
	 ~MyQStatusBar() { callbackQStatusBar_DestroyQStatusBar(this); };
	void actionEvent(QActionEvent * event) { callbackQStatusBar_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQStatusBar_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQStatusBar_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQStatusBar_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQStatusBar_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQStatusBar_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQStatusBar_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQStatusBar_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQStatusBar_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQStatusBar_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQStatusBar_MinimumSizeHint(const_cast<MyQStatusBar*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQStatusBar_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQStatusBar_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQStatusBar_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQStatusBar_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQStatusBar_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQStatusBar_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQStatusBar_SizeHint(const_cast<MyQStatusBar*>(this))); };
	void changeEvent(QEvent * event) { callbackQStatusBar_ChangeEvent(this, event); };
	bool close() { return callbackQStatusBar_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQStatusBar_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQStatusBar_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQStatusBar_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQStatusBar_HasHeightForWidth(const_cast<MyQStatusBar*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQStatusBar_HeightForWidth(const_cast<MyQStatusBar*>(this), w); };
	void hide() { callbackQStatusBar_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQStatusBar_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQStatusBar_InputMethodQuery(const_cast<MyQStatusBar*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQStatusBar_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQStatusBar_KeyReleaseEvent(this, event); };
	void lower() { callbackQStatusBar_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQStatusBar_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQStatusBar_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQStatusBar_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQStatusBar_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQStatusBar_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQStatusBar_Raise(this); };
	void repaint() { callbackQStatusBar_Repaint(this); };
	void setDisabled(bool disable) { callbackQStatusBar_SetDisabled(this, disable); };
	void setFocus() { callbackQStatusBar_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQStatusBar_SetHidden(this, hidden); };
	void show() { callbackQStatusBar_Show(this); };
	void showFullScreen() { callbackQStatusBar_ShowFullScreen(this); };
	void showMaximized() { callbackQStatusBar_ShowMaximized(this); };
	void showMinimized() { callbackQStatusBar_ShowMinimized(this); };
	void showNormal() { callbackQStatusBar_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQStatusBar_TabletEvent(this, event); };
	void update() { callbackQStatusBar_Update(this); };
	void updateMicroFocus() { callbackQStatusBar_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQStatusBar_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQStatusBar_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQStatusBar_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQStatusBar_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQStatusBar_CustomEvent(this, event); };
	void deleteLater() { callbackQStatusBar_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQStatusBar_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQStatusBar_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStatusBar_MetaObject(const_cast<MyQStatusBar*>(this))); };
};

char QStatusBar_IsSizeGripEnabled(void* ptr)
{
	return static_cast<QStatusBar*>(ptr)->isSizeGripEnabled();
}

void QStatusBar_PaintEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QStatusBar_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::paintEvent(static_cast<QPaintEvent*>(event));
}

void QStatusBar_SetSizeGripEnabled(void* ptr, char vbo)
{
	static_cast<QStatusBar*>(ptr)->setSizeGripEnabled(vbo != 0);
}

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");
}

char* QStatusBar_CurrentMessage(void* ptr)
{
	return const_cast<char*>(static_cast<QStatusBar*>(ptr)->currentMessage().toUtf8().prepend("WHITESPACE").constData()+10);
}

char QStatusBar_Event(void* ptr, void* e)
{
	return static_cast<QStatusBar*>(ptr)->event(static_cast<QEvent*>(e));
}

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);
}

void QStatusBar_ConnectMessageChanged(void* ptr)
{
	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));
}

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, char* message)
{
	static_cast<QStatusBar*>(ptr)->messageChanged(QString(message));
}

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_ResizeEvent(void* ptr, void* e)
{
	static_cast<QStatusBar*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(e));
}

void QStatusBar_ResizeEventDefault(void* ptr, void* e)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::resizeEvent(static_cast<QResizeEvent*>(e));
}

void QStatusBar_ShowEvent(void* ptr, void* vqs)
{
	static_cast<QStatusBar*>(ptr)->showEvent(static_cast<QShowEvent*>(vqs));
}

void QStatusBar_ShowEventDefault(void* ptr, void* vqs)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::showEvent(static_cast<QShowEvent*>(vqs));
}

void QStatusBar_ShowMessage(void* ptr, char* message, int timeout)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "showMessage", Q_ARG(QString, QString(message)), Q_ARG(int, timeout));
}

void QStatusBar_DestroyQStatusBar(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->~QStatusBar();
}

void QStatusBar_DestroyQStatusBarDefault(void* ptr)
{

}

void QStatusBar_ActionEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QStatusBar_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::actionEvent(static_cast<QActionEvent*>(event));
}

void QStatusBar_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QStatusBar_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QStatusBar_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QStatusBar_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QStatusBar_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QStatusBar_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QStatusBar_DropEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QStatusBar_DropEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::dropEvent(static_cast<QDropEvent*>(event));
}

void QStatusBar_EnterEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QStatusBar_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::enterEvent(static_cast<QEvent*>(event));
}

void QStatusBar_FocusInEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QStatusBar_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QStatusBar_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QStatusBar_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QStatusBar_HideEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QStatusBar_HideEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::hideEvent(static_cast<QHideEvent*>(event));
}

void QStatusBar_LeaveEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QStatusBar_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::leaveEvent(static_cast<QEvent*>(event));
}

void* QStatusBar_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStatusBar*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QStatusBar_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStatusBar*>(ptr)->QStatusBar::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStatusBar_MoveEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QStatusBar_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::moveEvent(static_cast<QMoveEvent*>(event));
}

void QStatusBar_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QStatusBar_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::setEnabled(vbo != 0);
}

void QStatusBar_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QStatusBar_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::setStyleSheet(QString(styleSheet));
}

void QStatusBar_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QStatusBar_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::setVisible(visible != 0);
}

void QStatusBar_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QStatusBar_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::setWindowModified(vbo != 0);
}

void QStatusBar_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QStatusBar_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::setWindowTitle(QString(vqs));
}

void* QStatusBar_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStatusBar*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QStatusBar_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStatusBar*>(ptr)->QStatusBar::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QStatusBar_ChangeEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QStatusBar_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::changeEvent(static_cast<QEvent*>(event));
}

char QStatusBar_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QStatusBar_CloseDefault(void* ptr)
{
	return static_cast<QStatusBar*>(ptr)->QStatusBar::close();
}

void QStatusBar_CloseEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QStatusBar_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::closeEvent(static_cast<QCloseEvent*>(event));
}

void QStatusBar_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QStatusBar_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QStatusBar_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QStatusBar*>(ptr)->focusNextPrevChild(next != 0);
}

char QStatusBar_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QStatusBar*>(ptr)->QStatusBar::focusNextPrevChild(next != 0);
}

char QStatusBar_HasHeightForWidth(void* ptr)
{
	return static_cast<QStatusBar*>(ptr)->hasHeightForWidth();
}

char QStatusBar_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QStatusBar*>(ptr)->QStatusBar::hasHeightForWidth();
}

int QStatusBar_HeightForWidth(void* ptr, int w)
{
	return static_cast<QStatusBar*>(ptr)->heightForWidth(w);
}

int QStatusBar_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QStatusBar*>(ptr)->QStatusBar::heightForWidth(w);
}

void QStatusBar_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "hide");
}

void QStatusBar_HideDefault(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::hide();
}

void QStatusBar_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QStatusBar_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QStatusBar_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QStatusBar*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QStatusBar_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QStatusBar*>(ptr)->QStatusBar::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QStatusBar_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QStatusBar_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QStatusBar_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QStatusBar_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QStatusBar_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "lower");
}

void QStatusBar_LowerDefault(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::lower();
}

void QStatusBar_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QStatusBar_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QStatusBar_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QStatusBar_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QStatusBar_MousePressEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QStatusBar_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QStatusBar_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QStatusBar_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QStatusBar_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QStatusBar*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QStatusBar_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QStatusBar*>(ptr)->QStatusBar::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QStatusBar_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "raise");
}

void QStatusBar_RaiseDefault(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::raise();
}

void QStatusBar_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "repaint");
}

void QStatusBar_RepaintDefault(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::repaint();
}

void QStatusBar_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QStatusBar_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::setDisabled(disable != 0);
}

void QStatusBar_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "setFocus");
}

void QStatusBar_SetFocus2Default(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::setFocus();
}

void QStatusBar_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QStatusBar_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::setHidden(hidden != 0);
}

void QStatusBar_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "show");
}

void QStatusBar_ShowDefault(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::show();
}

void QStatusBar_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "showFullScreen");
}

void QStatusBar_ShowFullScreenDefault(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::showFullScreen();
}

void QStatusBar_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "showMaximized");
}

void QStatusBar_ShowMaximizedDefault(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::showMaximized();
}

void QStatusBar_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "showMinimized");
}

void QStatusBar_ShowMinimizedDefault(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::showMinimized();
}

void QStatusBar_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "showNormal");
}

void QStatusBar_ShowNormalDefault(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::showNormal();
}

void QStatusBar_TabletEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QStatusBar_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QStatusBar_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "update");
}

void QStatusBar_UpdateDefault(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::update();
}

void QStatusBar_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "updateMicroFocus");
}

void QStatusBar_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::updateMicroFocus();
}

void QStatusBar_WheelEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QStatusBar_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QStatusBar_TimerEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QStatusBar_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::timerEvent(static_cast<QTimerEvent*>(event));
}

void QStatusBar_ChildEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QStatusBar_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::childEvent(static_cast<QChildEvent*>(event));
}

void QStatusBar_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QStatusBar*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStatusBar_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStatusBar_CustomEvent(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QStatusBar_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::customEvent(static_cast<QEvent*>(event));
}

void QStatusBar_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "deleteLater");
}

void QStatusBar_DeleteLaterDefault(void* ptr)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::deleteLater();
}

void QStatusBar_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QStatusBar*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStatusBar_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QStatusBar*>(ptr)->QStatusBar::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QStatusBar_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QStatusBar*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QStatusBar_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QStatusBar*>(ptr)->QStatusBar::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QStatusBar_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QStatusBar*>(ptr)->metaObject());
}

void* QStatusBar_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QStatusBar*>(ptr)->QStatusBar::metaObject());
}

int QStyle_PM_MdiSubWindowMinimizedWidth_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_MdiSubWindowMinimizedWidth;
	#else
		return 0;
	#endif
}

int QStyle_PM_HeaderMargin_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_HeaderMargin;
	#else
		return 0;
	#endif
}

int QStyle_PM_HeaderMarkSize_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_HeaderMarkSize;
	#else
		return 0;
	#endif
}

int QStyle_PM_HeaderGripMargin_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_HeaderGripMargin;
	#else
		return 0;
	#endif
}

int QStyle_PM_TabBarTabShiftHorizontal_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_TabBarTabShiftHorizontal;
	#else
		return 0;
	#endif
}

int QStyle_PM_TabBarTabShiftVertical_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_TabBarTabShiftVertical;
	#else
		return 0;
	#endif
}

int QStyle_PM_TabBarScrollButtonWidth_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_TabBarScrollButtonWidth;
	#else
		return 0;
	#endif
}

int QStyle_PM_ToolBarFrameWidth_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_ToolBarFrameWidth;
	#else
		return 0;
	#endif
}

int QStyle_PM_ToolBarHandleExtent_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_ToolBarHandleExtent;
	#else
		return 0;
	#endif
}

int QStyle_PM_ToolBarItemSpacing_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_ToolBarItemSpacing;
	#else
		return 0;
	#endif
}

int QStyle_PM_ToolBarItemMargin_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_ToolBarItemMargin;
	#else
		return 0;
	#endif
}

int QStyle_PM_ToolBarSeparatorExtent_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_ToolBarSeparatorExtent;
	#else
		return 0;
	#endif
}

int QStyle_PM_ToolBarExtensionExtent_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_ToolBarExtensionExtent;
	#else
		return 0;
	#endif
}

int QStyle_PM_SpinBoxSliderHeight_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_SpinBoxSliderHeight;
	#else
		return 0;
	#endif
}

int QStyle_PM_DefaultTopLevelMargin_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_DefaultTopLevelMargin;
	#else
		return 0;
	#endif
}

int QStyle_PM_DefaultChildMargin_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_DefaultChildMargin;
	#else
		return 0;
	#endif
}

int QStyle_PM_DefaultLayoutSpacing_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_DefaultLayoutSpacing;
	#else
		return 0;
	#endif
}

int QStyle_PM_ToolBarIconSize_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_ToolBarIconSize;
	#else
		return 0;
	#endif
}

int QStyle_PM_ListViewIconSize_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_ListViewIconSize;
	#else
		return 0;
	#endif
}

int QStyle_PM_IconViewIconSize_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_IconViewIconSize;
	#else
		return 0;
	#endif
}

int QStyle_PM_SmallIconSize_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_SmallIconSize;
	#else
		return 0;
	#endif
}

int QStyle_PM_LargeIconSize_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_LargeIconSize;
	#else
		return 0;
	#endif
}

int QStyle_PM_FocusFrameVMargin_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_FocusFrameVMargin;
	#else
		return 0;
	#endif
}

int QStyle_PM_FocusFrameHMargin_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_FocusFrameHMargin;
	#else
		return 0;
	#endif
}

int QStyle_PM_ToolTipLabelFrameWidth_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_ToolTipLabelFrameWidth;
	#else
		return 0;
	#endif
}

int QStyle_PM_CheckBoxLabelSpacing_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_CheckBoxLabelSpacing;
	#else
		return 0;
	#endif
}

int QStyle_PM_TabBarIconSize_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_TabBarIconSize;
	#else
		return 0;
	#endif
}

int QStyle_PM_SizeGripSize_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_SizeGripSize;
	#else
		return 0;
	#endif
}

int QStyle_PM_DockWidgetTitleMargin_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_DockWidgetTitleMargin;
	#else
		return 0;
	#endif
}

int QStyle_PM_MessageBoxIconSize_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_MessageBoxIconSize;
	#else
		return 0;
	#endif
}

int QStyle_PM_ButtonIconSize_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_ButtonIconSize;
	#else
		return 0;
	#endif
}

int QStyle_PM_DockWidgetTitleBarButtonMargin_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_DockWidgetTitleBarButtonMargin;
	#else
		return 0;
	#endif
}

int QStyle_PM_RadioButtonLabelSpacing_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_RadioButtonLabelSpacing;
	#else
		return 0;
	#endif
}

int QStyle_PM_LayoutLeftMargin_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_LayoutLeftMargin;
	#else
		return 0;
	#endif
}

int QStyle_PM_LayoutTopMargin_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_LayoutTopMargin;
	#else
		return 0;
	#endif
}

int QStyle_PM_LayoutRightMargin_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_LayoutRightMargin;
	#else
		return 0;
	#endif
}

int QStyle_PM_LayoutBottomMargin_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_LayoutBottomMargin;
	#else
		return 0;
	#endif
}

int QStyle_PM_LayoutHorizontalSpacing_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_LayoutHorizontalSpacing;
	#else
		return 0;
	#endif
}

int QStyle_PM_LayoutVerticalSpacing_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_LayoutVerticalSpacing;
	#else
		return 0;
	#endif
}

int QStyle_PM_TabBar_ScrollButtonOverlap_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_TabBar_ScrollButtonOverlap;
	#else
		return 0;
	#endif
}

int QStyle_PM_TextCursorWidth_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_TextCursorWidth;
	#else
		return 0;
	#endif
}

int QStyle_PM_TabCloseIndicatorWidth_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_TabCloseIndicatorWidth;
	#else
		return 0;
	#endif
}

int QStyle_PM_TabCloseIndicatorHeight_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_TabCloseIndicatorHeight;
	#else
		return 0;
	#endif
}

int QStyle_PM_ScrollView_ScrollBarSpacing_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_ScrollView_ScrollBarSpacing;
	#else
		return 0;
	#endif
}

int QStyle_PM_ScrollView_ScrollBarOverlap_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_ScrollView_ScrollBarOverlap;
	#else
		return 0;
	#endif
}

int QStyle_PM_SubMenuOverlap_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_SubMenuOverlap;
	#else
		return 0;
	#endif
}

int QStyle_PM_TreeViewIndentation_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_TreeViewIndentation;
	#else
		return 0;
	#endif
}

int QStyle_PM_HeaderDefaultSectionSizeHorizontal_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_HeaderDefaultSectionSizeHorizontal;
	#else
		return 0;
	#endif
}

int QStyle_PM_HeaderDefaultSectionSizeVertical_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::PM_HeaderDefaultSectionSizeVertical;
	#else
		return 0;
	#endif
}

int QStyle_PE_FrameTabWidget_Type()
{
	return QStyle::PE_FrameTabWidget;
}

int QStyle_PE_FrameWindow_Type()
{
	return QStyle::PE_FrameWindow;
}

int QStyle_PE_FrameButtonBevel_Type()
{
	return QStyle::PE_FrameButtonBevel;
}

int QStyle_PE_FrameButtonTool_Type()
{
	return QStyle::PE_FrameButtonTool;
}

int QStyle_PE_FrameTabBarBase_Type()
{
	return QStyle::PE_FrameTabBarBase;
}

int QStyle_PE_PanelButtonCommand_Type()
{
	return QStyle::PE_PanelButtonCommand;
}

int QStyle_PE_PanelButtonBevel_Type()
{
	return QStyle::PE_PanelButtonBevel;
}

int QStyle_PE_PanelButtonTool_Type()
{
	return QStyle::PE_PanelButtonTool;
}

int QStyle_PE_PanelMenuBar_Type()
{
	return QStyle::PE_PanelMenuBar;
}

int QStyle_PE_PanelToolBar_Type()
{
	return QStyle::PE_PanelToolBar;
}

int QStyle_PE_PanelLineEdit_Type()
{
	return QStyle::PE_PanelLineEdit;
}

int QStyle_PE_IndicatorArrowDown_Type()
{
	return QStyle::PE_IndicatorArrowDown;
}

int QStyle_PE_IndicatorArrowLeft_Type()
{
	return QStyle::PE_IndicatorArrowLeft;
}

int QStyle_PE_IndicatorArrowRight_Type()
{
	return QStyle::PE_IndicatorArrowRight;
}

int QStyle_PE_IndicatorArrowUp_Type()
{
	return QStyle::PE_IndicatorArrowUp;
}

int QStyle_PE_IndicatorBranch_Type()
{
	return QStyle::PE_IndicatorBranch;
}

int QStyle_PE_IndicatorButtonDropDown_Type()
{
	return QStyle::PE_IndicatorButtonDropDown;
}

int QStyle_PE_IndicatorViewItemCheck_Type()
{
	return QStyle::PE_IndicatorViewItemCheck;
}

int QStyle_PE_IndicatorCheckBox_Type()
{
	return QStyle::PE_IndicatorCheckBox;
}

int QStyle_PE_IndicatorDockWidgetResizeHandle_Type()
{
	return QStyle::PE_IndicatorDockWidgetResizeHandle;
}

int QStyle_PE_IndicatorHeaderArrow_Type()
{
	return QStyle::PE_IndicatorHeaderArrow;
}

int QStyle_PE_IndicatorMenuCheckMark_Type()
{
	return QStyle::PE_IndicatorMenuCheckMark;
}

int QStyle_PE_IndicatorProgressChunk_Type()
{
	return QStyle::PE_IndicatorProgressChunk;
}

int QStyle_PE_IndicatorRadioButton_Type()
{
	return QStyle::PE_IndicatorRadioButton;
}

int QStyle_PE_IndicatorSpinDown_Type()
{
	return QStyle::PE_IndicatorSpinDown;
}

int QStyle_PE_IndicatorSpinMinus_Type()
{
	return QStyle::PE_IndicatorSpinMinus;
}

int QStyle_PE_IndicatorSpinPlus_Type()
{
	return QStyle::PE_IndicatorSpinPlus;
}

int QStyle_PE_IndicatorSpinUp_Type()
{
	return QStyle::PE_IndicatorSpinUp;
}

int QStyle_PE_IndicatorToolBarHandle_Type()
{
	return QStyle::PE_IndicatorToolBarHandle;
}

int QStyle_PE_IndicatorToolBarSeparator_Type()
{
	return QStyle::PE_IndicatorToolBarSeparator;
}

int QStyle_PE_PanelTipLabel_Type()
{
	return QStyle::PE_PanelTipLabel;
}

int QStyle_PE_IndicatorTabTear_Type()
{
	return QStyle::PE_IndicatorTabTear;
}

int QStyle_PE_PanelScrollAreaCorner_Type()
{
	return QStyle::PE_PanelScrollAreaCorner;
}

int QStyle_PE_Widget_Type()
{
	return QStyle::PE_Widget;
}

int QStyle_PE_IndicatorColumnViewArrow_Type()
{
	return QStyle::PE_IndicatorColumnViewArrow;
}

int QStyle_PE_IndicatorItemViewItemDrop_Type()
{
	return QStyle::PE_IndicatorItemViewItemDrop;
}

int QStyle_PE_PanelItemViewItem_Type()
{
	return QStyle::PE_PanelItemViewItem;
}

int QStyle_PE_PanelItemViewRow_Type()
{
	return QStyle::PE_PanelItemViewRow;
}

int QStyle_PE_PanelStatusBar_Type()
{
	return QStyle::PE_PanelStatusBar;
}

int QStyle_PE_IndicatorTabClose_Type()
{
	return QStyle::PE_IndicatorTabClose;
}

int QStyle_PE_PanelMenu_Type()
{
	return QStyle::PE_PanelMenu;
}

int QStyle_PE_IndicatorTabTearRight_Type()
{
	return QStyle::PE_IndicatorTabTearRight;
}

int QStyle_SH_BlinkCursorWhenTextSelected_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_BlinkCursorWhenTextSelected;
	#else
		return 0;
	#endif
}

int QStyle_SH_RichText_FullWidthSelection_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_RichText_FullWidthSelection;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_Scrollable_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_Scrollable;
	#else
		return 0;
	#endif
}

int QStyle_SH_GroupBox_TextLabelVerticalAlignment_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_GroupBox_TextLabelVerticalAlignment;
	#else
		return 0;
	#endif
}

int QStyle_SH_GroupBox_TextLabelColor_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_GroupBox_TextLabelColor;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_SloppySubMenus_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_SloppySubMenus;
	#else
		return 0;
	#endif
}

int QStyle_SH_Table_GridLineColor_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Table_GridLineColor;
	#else
		return 0;
	#endif
}

int QStyle_SH_LineEdit_PasswordCharacter_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_LineEdit_PasswordCharacter;
	#else
		return 0;
	#endif
}

int QStyle_SH_DialogButtons_DefaultButton_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_DialogButtons_DefaultButton;
	#else
		return 0;
	#endif
}

int QStyle_SH_ToolBox_SelectedPageTitleBold_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ToolBox_SelectedPageTitleBold;
	#else
		return 0;
	#endif
}

int QStyle_SH_TabBar_PreferNoArrows_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_TabBar_PreferNoArrows;
	#else
		return 0;
	#endif
}

int QStyle_SH_ScrollBar_LeftClickAbsolutePosition_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ScrollBar_LeftClickAbsolutePosition;
	#else
		return 0;
	#endif
}

int QStyle_SH_ListViewExpand_SelectMouseType_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ListViewExpand_SelectMouseType;
	#else
		return 0;
	#endif
}

int QStyle_SH_UnderlineShortcut_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_UnderlineShortcut;
	#else
		return 0;
	#endif
}

int QStyle_SH_SpinBox_AnimateButton_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_SpinBox_AnimateButton;
	#else
		return 0;
	#endif
}

int QStyle_SH_SpinBox_KeyPressAutoRepeatRate_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_SpinBox_KeyPressAutoRepeatRate;
	#else
		return 0;
	#endif
}

int QStyle_SH_SpinBox_ClickAutoRepeatRate_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_SpinBox_ClickAutoRepeatRate;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_FillScreenWithScroll_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_FillScreenWithScroll;
	#else
		return 0;
	#endif
}

int QStyle_SH_ToolTipLabel_Opacity_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ToolTipLabel_Opacity;
	#else
		return 0;
	#endif
}

int QStyle_SH_DrawMenuBarSeparator_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_DrawMenuBarSeparator;
	#else
		return 0;
	#endif
}

int QStyle_SH_TitleBar_ModifyNotification_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_TitleBar_ModifyNotification;
	#else
		return 0;
	#endif
}

int QStyle_SH_Button_FocusPolicy_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Button_FocusPolicy;
	#else
		return 0;
	#endif
}

int QStyle_SH_MessageBox_UseBorderForButtonSpacing_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_MessageBox_UseBorderForButtonSpacing;
	#else
		return 0;
	#endif
}

int QStyle_SH_TitleBar_AutoRaise_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_TitleBar_AutoRaise;
	#else
		return 0;
	#endif
}

int QStyle_SH_ToolButton_PopupDelay_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ToolButton_PopupDelay;
	#else
		return 0;
	#endif
}

int QStyle_SH_FocusFrame_Mask_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_FocusFrame_Mask;
	#else
		return 0;
	#endif
}

int QStyle_SH_RubberBand_Mask_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_RubberBand_Mask;
	#else
		return 0;
	#endif
}

int QStyle_SH_WindowFrame_Mask_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_WindowFrame_Mask;
	#else
		return 0;
	#endif
}

int QStyle_SH_SpinControls_DisableOnBounds_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_SpinControls_DisableOnBounds;
	#else
		return 0;
	#endif
}

int QStyle_SH_Dial_BackgroundRole_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Dial_BackgroundRole;
	#else
		return 0;
	#endif
}

int QStyle_SH_ComboBox_LayoutDirection_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ComboBox_LayoutDirection;
	#else
		return 0;
	#endif
}

int QStyle_SH_ItemView_EllipsisLocation_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ItemView_EllipsisLocation;
	#else
		return 0;
	#endif
}

int QStyle_SH_ItemView_ShowDecorationSelected_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ItemView_ShowDecorationSelected;
	#else
		return 0;
	#endif
}

int QStyle_SH_ItemView_ActivateItemOnSingleClick_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ItemView_ActivateItemOnSingleClick;
	#else
		return 0;
	#endif
}

int QStyle_SH_ScrollBar_ContextMenu_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ScrollBar_ContextMenu;
	#else
		return 0;
	#endif
}

int QStyle_SH_ScrollBar_RollBetweenButtons_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ScrollBar_RollBetweenButtons;
	#else
		return 0;
	#endif
}

int QStyle_SH_Slider_AbsoluteSetButtons_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Slider_AbsoluteSetButtons;
	#else
		return 0;
	#endif
}

int QStyle_SH_Slider_PageSetButtons_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Slider_PageSetButtons;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_KeyboardSearch_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_KeyboardSearch;
	#else
		return 0;
	#endif
}

int QStyle_SH_TabBar_ElideMode_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_TabBar_ElideMode;
	#else
		return 0;
	#endif
}

int QStyle_SH_DialogButtonLayout_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_DialogButtonLayout;
	#else
		return 0;
	#endif
}

int QStyle_SH_ComboBox_PopupFrameStyle_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ComboBox_PopupFrameStyle;
	#else
		return 0;
	#endif
}

int QStyle_SH_MessageBox_TextInteractionFlags_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_MessageBox_TextInteractionFlags;
	#else
		return 0;
	#endif
}

int QStyle_SH_DialogButtonBox_ButtonsHaveIcons_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_DialogButtonBox_ButtonsHaveIcons;
	#else
		return 0;
	#endif
}

int QStyle_SH_SpellCheckUnderlineStyle_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_SpellCheckUnderlineStyle;
	#else
		return 0;
	#endif
}

int QStyle_SH_MessageBox_CenterButtons_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_MessageBox_CenterButtons;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_SelectionWrap_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_SelectionWrap;
	#else
		return 0;
	#endif
}

int QStyle_SH_ItemView_MovementWithoutUpdatingSelection_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ItemView_MovementWithoutUpdatingSelection;
	#else
		return 0;
	#endif
}

int QStyle_SH_ToolTip_Mask_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ToolTip_Mask;
	#else
		return 0;
	#endif
}

int QStyle_SH_FocusFrame_AboveWidget_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_FocusFrame_AboveWidget;
	#else
		return 0;
	#endif
}

int QStyle_SH_TextControl_FocusIndicatorTextCharFormat_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_TextControl_FocusIndicatorTextCharFormat;
	#else
		return 0;
	#endif
}

int QStyle_SH_WizardStyle_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_WizardStyle;
	#else
		return 0;
	#endif
}

int QStyle_SH_ItemView_ArrowKeysNavigateIntoChildren_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ItemView_ArrowKeysNavigateIntoChildren;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_Mask_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_Mask;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_FlashTriggeredItem_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_FlashTriggeredItem;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_FadeOutOnHide_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_FadeOutOnHide;
	#else
		return 0;
	#endif
}

int QStyle_SH_SpinBox_ClickAutoRepeatThreshold_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_SpinBox_ClickAutoRepeatThreshold;
	#else
		return 0;
	#endif
}

int QStyle_SH_ItemView_PaintAlternatingRowColorsForEmptyArea_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ItemView_PaintAlternatingRowColorsForEmptyArea;
	#else
		return 0;
	#endif
}

int QStyle_SH_FormLayoutWrapPolicy_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_FormLayoutWrapPolicy;
	#else
		return 0;
	#endif
}

int QStyle_SH_TabWidget_DefaultTabPosition_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_TabWidget_DefaultTabPosition;
	#else
		return 0;
	#endif
}

int QStyle_SH_ToolBar_Movable_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ToolBar_Movable;
	#else
		return 0;
	#endif
}

int QStyle_SH_FormLayoutFieldGrowthPolicy_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_FormLayoutFieldGrowthPolicy;
	#else
		return 0;
	#endif
}

int QStyle_SH_FormLayoutFormAlignment_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_FormLayoutFormAlignment;
	#else
		return 0;
	#endif
}

int QStyle_SH_FormLayoutLabelAlignment_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_FormLayoutLabelAlignment;
	#else
		return 0;
	#endif
}

int QStyle_SH_ItemView_DrawDelegateFrame_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ItemView_DrawDelegateFrame;
	#else
		return 0;
	#endif
}

int QStyle_SH_TabBar_CloseButtonPosition_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_TabBar_CloseButtonPosition;
	#else
		return 0;
	#endif
}

int QStyle_SH_DockWidget_ButtonsHaveFrame_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_DockWidget_ButtonsHaveFrame;
	#else
		return 0;
	#endif
}

int QStyle_SH_ToolButtonStyle_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ToolButtonStyle;
	#else
		return 0;
	#endif
}

int QStyle_SH_RequestSoftwareInputPanel_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_RequestSoftwareInputPanel;
	#else
		return 0;
	#endif
}

int QStyle_SH_ScrollBar_Transient_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ScrollBar_Transient;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_SupportsSections_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_SupportsSections;
	#else
		return 0;
	#endif
}

int QStyle_SH_ToolTip_WakeUpDelay_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ToolTip_WakeUpDelay;
	#else
		return 0;
	#endif
}

int QStyle_SH_ToolTip_FallAsleepDelay_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ToolTip_FallAsleepDelay;
	#else
		return 0;
	#endif
}

int QStyle_SH_Widget_Animate_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Widget_Animate;
	#else
		return 0;
	#endif
}

int QStyle_SH_Splitter_OpaqueResize_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Splitter_OpaqueResize;
	#else
		return 0;
	#endif
}

int QStyle_SH_ComboBox_UseNativePopup_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ComboBox_UseNativePopup;
	#else
		return 0;
	#endif
}

int QStyle_SH_LineEdit_PasswordMaskDelay_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_LineEdit_PasswordMaskDelay;
	#else
		return 0;
	#endif
}

int QStyle_SH_TabBar_ChangeCurrentDelay_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_TabBar_ChangeCurrentDelay;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_SubMenuUniDirection_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_SubMenuUniDirection;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_SubMenuUniDirectionFailCount_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_SubMenuUniDirectionFailCount;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_SubMenuSloppySelectOtherActions_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_SubMenuSloppySelectOtherActions;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_SubMenuSloppyCloseTimeout_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_SubMenuSloppyCloseTimeout;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_SubMenuResetWhenReenteringParent_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_SubMenuResetWhenReenteringParent;
	#else
		return 0;
	#endif
}

int QStyle_SH_Menu_SubMenuDontStartSloppyOnLeave_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_Menu_SubMenuDontStartSloppyOnLeave;
	#else
		return 0;
	#endif
}

int QStyle_SH_ItemView_ScrollMode_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyle::SH_ItemView_ScrollMode;
	#else
		return 0;
	#endif
}

int QStyle_SE_TabBarTearIndicator_Type()
{
	return QStyle::SE_TabBarTearIndicator;
}

int QStyle_SE_TreeViewDisclosureItem_Type()
{
	return QStyle::SE_TreeViewDisclosureItem;
}

int QStyle_SE_LineEditContents_Type()
{
	return QStyle::SE_LineEditContents;
}

int QStyle_SE_FrameContents_Type()
{
	return QStyle::SE_FrameContents;
}

int QStyle_SE_DockWidgetCloseButton_Type()
{
	return QStyle::SE_DockWidgetCloseButton;
}

int QStyle_SE_DockWidgetFloatButton_Type()
{
	return QStyle::SE_DockWidgetFloatButton;
}

int QStyle_SE_DockWidgetTitleBarText_Type()
{
	return QStyle::SE_DockWidgetTitleBarText;
}

int QStyle_SE_DockWidgetIcon_Type()
{
	return QStyle::SE_DockWidgetIcon;
}

int QStyle_SE_CheckBoxLayoutItem_Type()
{
	return QStyle::SE_CheckBoxLayoutItem;
}

int QStyle_SE_ComboBoxLayoutItem_Type()
{
	return QStyle::SE_ComboBoxLayoutItem;
}

int QStyle_SE_DateTimeEditLayoutItem_Type()
{
	return QStyle::SE_DateTimeEditLayoutItem;
}

int QStyle_SE_DialogButtonBoxLayoutItem_Type()
{
	return QStyle::SE_DialogButtonBoxLayoutItem;
}

int QStyle_SE_LabelLayoutItem_Type()
{
	return QStyle::SE_LabelLayoutItem;
}

int QStyle_SE_ProgressBarLayoutItem_Type()
{
	return QStyle::SE_ProgressBarLayoutItem;
}

int QStyle_SE_PushButtonLayoutItem_Type()
{
	return QStyle::SE_PushButtonLayoutItem;
}

int QStyle_SE_RadioButtonLayoutItem_Type()
{
	return QStyle::SE_RadioButtonLayoutItem;
}

int QStyle_SE_SliderLayoutItem_Type()
{
	return QStyle::SE_SliderLayoutItem;
}

int QStyle_SE_SpinBoxLayoutItem_Type()
{
	return QStyle::SE_SpinBoxLayoutItem;
}

int QStyle_SE_ToolButtonLayoutItem_Type()
{
	return QStyle::SE_ToolButtonLayoutItem;
}

int QStyle_SE_FrameLayoutItem_Type()
{
	return QStyle::SE_FrameLayoutItem;
}

int QStyle_SE_GroupBoxLayoutItem_Type()
{
	return QStyle::SE_GroupBoxLayoutItem;
}

int QStyle_SE_TabWidgetLayoutItem_Type()
{
	return QStyle::SE_TabWidgetLayoutItem;
}

int QStyle_SE_ItemViewItemDecoration_Type()
{
	return QStyle::SE_ItemViewItemDecoration;
}

int QStyle_SE_ItemViewItemText_Type()
{
	return QStyle::SE_ItemViewItemText;
}

int QStyle_SE_ItemViewItemFocusRect_Type()
{
	return QStyle::SE_ItemViewItemFocusRect;
}

int QStyle_SE_TabBarTabLeftButton_Type()
{
	return QStyle::SE_TabBarTabLeftButton;
}

int QStyle_SE_TabBarTabRightButton_Type()
{
	return QStyle::SE_TabBarTabRightButton;
}

int QStyle_SE_TabBarTabText_Type()
{
	return QStyle::SE_TabBarTabText;
}

int QStyle_SE_ShapedFrameContents_Type()
{
	return QStyle::SE_ShapedFrameContents;
}

int QStyle_SE_ToolBarHandle_Type()
{
	return QStyle::SE_ToolBarHandle;
}

int QStyle_SE_TabBarScrollLeftButton_Type()
{
	return QStyle::SE_TabBarScrollLeftButton;
}

int QStyle_SE_TabBarScrollRightButton_Type()
{
	return QStyle::SE_TabBarScrollRightButton;
}

int QStyle_SE_TabBarTearIndicatorRight_Type()
{
	return QStyle::SE_TabBarTearIndicatorRight;
}

class MyQStyle: public QStyle
{
public:
	MyQStyle() : QStyle() {};
	void drawItemPixmap(QPainter * painter, const QRect & rectangle, int alignment, const QPixmap & pixmap) const { callbackQStyle_DrawItemPixmap(const_cast<MyQStyle*>(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 { callbackQStyle_DrawItemText(const_cast<MyQStyle*>(this), painter, const_cast<QRect*>(&rectangle), alignment, const_cast<QPalette*>(&palette), enabled, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10), textRole); };
	QRect itemPixmapRect(const QRect & rectangle, int alignment, const QPixmap & pixmap) const { return *static_cast<QRect*>(callbackQStyle_ItemPixmapRect(const_cast<MyQStyle*>(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 { return *static_cast<QRect*>(callbackQStyle_ItemTextRect(const_cast<MyQStyle*>(this), const_cast<QFontMetrics*>(&metrics), const_cast<QRect*>(&rectangle), alignment, enabled, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10))); };
	void polish(QApplication * application) { callbackQStyle_Polish2(this, application); };
	void polish(QPalette & palette) { callbackQStyle_Polish3(this, new QPalette(palette)); };
	void unpolish(QApplication * application) { callbackQStyle_Unpolish2(this, application); };
	void drawComplexControl(QStyle::ComplexControl control, const QStyleOptionComplex * option, QPainter * painter, const QWidget * widget) const { callbackQStyle_DrawComplexControl(const_cast<MyQStyle*>(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<MyQStyle*>(this), element, const_cast<QStyleOption*>(option), painter, const_cast<QWidget*>(widget)); };
	void drawPrimitive(QStyle::PrimitiveElement element, const QStyleOption * option, QPainter * painter, const QWidget * widget) const { callbackQStyle_DrawPrimitive(const_cast<MyQStyle*>(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<MyQStyle*>(this), iconMode, const_cast<QPixmap*>(&pixmap), const_cast<QStyleOption*>(option))); };
	SubControl hitTestComplexControl(QStyle::ComplexControl control, const QStyleOptionComplex * option, const QPoint & position, const QWidget * widget) const { return static_cast<QStyle::SubControl>(callbackQStyle_HitTestComplexControl(const_cast<MyQStyle*>(this), control, const_cast<QStyleOptionComplex*>(option), const_cast<QPoint*>(&position), const_cast<QWidget*>(widget))); };
	int layoutSpacing(QSizePolicy::ControlType control1, QSizePolicy::ControlType control2, Qt::Orientation orientation, const QStyleOption * option, const QWidget * widget) const { return callbackQStyle_LayoutSpacing(const_cast<MyQStyle*>(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<MyQStyle*>(this), metric, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget)); };
	void polish(QWidget * widget) { callbackQStyle_Polish(this, widget); };
	QSize sizeFromContents(QStyle::ContentsType ty, const QStyleOption * option, const QSize & contentsSize, const QWidget * widget) const { return *static_cast<QSize*>(callbackQStyle_SizeFromContents(const_cast<MyQStyle*>(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<MyQStyle*>(this), standardIcon, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
	QPalette standardPalette() const { return *static_cast<QPalette*>(callbackQStyle_StandardPalette(const_cast<MyQStyle*>(this))); };
	int styleHint(QStyle::StyleHint hint, const QStyleOption * option, const QWidget * widget, QStyleHintReturn * returnData) const { return callbackQStyle_StyleHint(const_cast<MyQStyle*>(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<MyQStyle*>(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<MyQStyle*>(this), element, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
	void unpolish(QWidget * widget) { callbackQStyle_Unpolish(this, widget); };
	 ~MyQStyle() { callbackQStyle_DestroyQStyle(this); };
	QPixmap standardPixmap(QStyle::StandardPixmap standardIcon, const QStyleOption * option, const QWidget * widget) const { return *static_cast<QPixmap*>(callbackQStyle_StandardPixmap(const_cast<MyQStyle*>(this), standardIcon, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
	void timerEvent(QTimerEvent * event) { callbackQStyle_TimerEvent(this, event); };
	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 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<MyQStyle*>(this))); };
};

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)
{
	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, char* 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(text), static_cast<QPalette::ColorRole>(textRole));
}

void QStyle_DrawItemTextDefault(void* ptr, void* painter, void* rectangle, int alignment, void* palette, char enabled, char* text, long long textRole)
{
	static_cast<QStyle*>(ptr)->QStyle::drawItemText(static_cast<QPainter*>(painter), *static_cast<QRect*>(rectangle), alignment, *static_cast<QPalette*>(palette), enabled != 0, QString(text), static_cast<QPalette::ColorRole>(textRole));
}

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)
{
	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, char* text)
{
	return ({ QRect tmpValue = static_cast<QStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QStyle_ItemTextRectDefault(void* ptr, void* metrics, void* rectangle, int alignment, char enabled, char* text)
{
	return ({ QRect tmpValue = static_cast<QStyle*>(ptr)->QStyle::itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QStyle_Polish2(void* ptr, void* application)
{
	static_cast<QStyle*>(ptr)->polish(static_cast<QApplication*>(application));
}

void QStyle_Polish2Default(void* ptr, void* application)
{
	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)
{
	static_cast<QStyle*>(ptr)->QStyle::polish(*static_cast<QPalette*>(palette));
}

void* QStyle_Proxy(void* ptr)
{
	return const_cast<QStyle*>(static_cast<QStyle*>(ptr)->proxy());
}

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_Unpolish2(void* ptr, void* application)
{
	static_cast<QStyle*>(ptr)->unpolish(static_cast<QApplication*>(application));
}

void QStyle_Unpolish2Default(void* ptr, void* application)
{
	static_cast<QStyle*>(ptr)->QStyle::unpolish(static_cast<QApplication*>(application));
}

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_NewQStyle()
{
	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_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));
}

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)
{
	static_cast<QStyle*>(ptr)->QStyle::polish(static_cast<QWidget*>(widget));
}

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);
}

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)
{
	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)
{
	static_cast<QStyle*>(ptr)->QStyle::unpolish(static_cast<QWidget*>(widget));
}

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_DestroyQStyle(void* ptr)
{
	static_cast<QStyle*>(ptr)->~QStyle();
}

void QStyle_DestroyQStyleDefault(void* 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_TimerEvent(void* ptr, void* event)
{
	static_cast<QStyle*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QStyle_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QStyle*>(ptr)->QStyle::timerEvent(static_cast<QTimerEvent*>(event));
}

void QStyle_ChildEvent(void* ptr, void* event)
{
	static_cast<QStyle*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QStyle_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QStyle*>(ptr)->QStyle::childEvent(static_cast<QChildEvent*>(event));
}

void QStyle_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QStyle*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStyle_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QStyle*>(ptr)->QStyle::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStyle_CustomEvent(void* ptr, void* event)
{
	static_cast<QStyle*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QStyle_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QStyle*>(ptr)->QStyle::customEvent(static_cast<QEvent*>(event));
}

void QStyle_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStyle*>(ptr), "deleteLater");
}

void QStyle_DeleteLaterDefault(void* ptr)
{
	static_cast<QStyle*>(ptr)->QStyle::deleteLater();
}

void QStyle_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QStyle*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStyle_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QStyle*>(ptr)->QStyle::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QStyle_Event(void* ptr, void* e)
{
	return static_cast<QStyle*>(ptr)->event(static_cast<QEvent*>(e));
}

char QStyle_EventDefault(void* ptr, void* e)
{
	return static_cast<QStyle*>(ptr)->QStyle::event(static_cast<QEvent*>(e));
}

char QStyle_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QStyle*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QStyle_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QStyle*>(ptr)->QStyle::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QStyle_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QStyle*>(ptr)->metaObject());
}

void* QStyle_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QStyle*>(ptr)->QStyle::metaObject());
}

void* QStyleFactory_QStyleFactory_Create(char* key)
{
	return QStyleFactory::create(QString(key));
}

char* QStyleFactory_QStyleFactory_Keys()
{
	return const_cast<char*>(QStyleFactory::keys().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

int QStyleHintReturn_SH_Mask_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyleHintReturn::SH_Mask;
	#else
		return 0;
	#endif
}

int QStyleHintReturn_SH_Variant_Type()
{
	#if QT_VERSION >= 0x056000
		return QStyleHintReturn::SH_Variant;
	#else
		return 0;
	#endif
}

void* QStyleHintReturn_NewQStyleHintReturn(int version, int ty)
{
	return new QStyleHintReturn(version, ty);
}

int QStyleHintReturn_Type(void* ptr)
{
	return static_cast<QStyleHintReturn*>(ptr)->type;
}

void QStyleHintReturn_SetType(void* ptr, int vin)
{
	static_cast<QStyleHintReturn*>(ptr)->type = vin;
}

int QStyleHintReturn_Version(void* ptr)
{
	return static_cast<QStyleHintReturn*>(ptr)->version;
}

void QStyleHintReturn_SetVersion(void* ptr, int vin)
{
	static_cast<QStyleHintReturn*>(ptr)->version = vin;
}

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);
}

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);
}

int QStyleOption_SO_Slider_Type()
{
	return QStyleOption::SO_Slider;
}

int QStyleOption_SO_SpinBox_Type()
{
	return QStyleOption::SO_SpinBox;
}

int QStyleOption_SO_ToolButton_Type()
{
	return QStyleOption::SO_ToolButton;
}

int QStyleOption_SO_ComboBox_Type()
{
	return QStyleOption::SO_ComboBox;
}

int QStyleOption_SO_TitleBar_Type()
{
	return QStyleOption::SO_TitleBar;
}

int QStyleOption_SO_GroupBox_Type()
{
	return QStyleOption::SO_GroupBox;
}

int QStyleOption_SO_SizeGrip_Type()
{
	return QStyleOption::SO_SizeGrip;
}

void* QStyleOption_NewQStyleOption2(void* other)
{
	return new QStyleOption(*static_cast<QStyleOption*>(other));
}

void* QStyleOption_NewQStyleOption(int version, int ty)
{
	return new QStyleOption(version, ty);
}

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();
}

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_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_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);
}

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);
}

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);
}

int QStyleOption_Type(void* ptr)
{
	return static_cast<QStyleOption*>(ptr)->type;
}

void QStyleOption_SetType(void* ptr, int vin)
{
	static_cast<QStyleOption*>(ptr)->type = vin;
}

int QStyleOption_Version(void* ptr)
{
	return static_cast<QStyleOption*>(ptr)->version;
}

void QStyleOption_SetVersion(void* ptr, int vin)
{
	static_cast<QStyleOption*>(ptr)->version = vin;
}

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 vbu)
{
	static_cast<QStyleOptionButton*>(ptr)->features = static_cast<QStyleOptionButton::ButtonFeature>(vbu);
}

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);
}

char* QStyleOptionButton_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QStyleOptionButton*>(ptr)->text.toUtf8().prepend("WHITESPACE").constData()+10);
}

void QStyleOptionButton_SetText(void* ptr, char* vqs)
{
	static_cast<QStyleOptionButton*>(ptr)->text = QString(vqs);
}

void* QStyleOptionComboBox_NewQStyleOptionComboBox()
{
	return new QStyleOptionComboBox();
}

void* QStyleOptionComboBox_NewQStyleOptionComboBox2(void* other)
{
	return new QStyleOptionComboBox(*static_cast<QStyleOptionComboBox*>(other));
}

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);
}

char* QStyleOptionComboBox_CurrentText(void* ptr)
{
	return const_cast<char*>(static_cast<QStyleOptionComboBox*>(ptr)->currentText.toUtf8().prepend("WHITESPACE").constData()+10);
}

void QStyleOptionComboBox_SetCurrentText(void* ptr, char* vqs)
{
	static_cast<QStyleOptionComboBox*>(ptr)->currentText = QString(vqs);
}

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;
}

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;
}

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);
}

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);
}

void* QStyleOptionComplex_NewQStyleOptionComplex2(void* other)
{
	return new QStyleOptionComplex(*static_cast<QStyleOptionComplex*>(other));
}

void* QStyleOptionComplex_NewQStyleOptionComplex(int version, int ty)
{
	return new QStyleOptionComplex(version, ty);
}

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);
}

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);
}

void* QStyleOptionDockWidget_NewQStyleOptionDockWidget()
{
	return new QStyleOptionDockWidget();
}

void* QStyleOptionDockWidget_NewQStyleOptionDockWidget2(void* other)
{
	return new QStyleOptionDockWidget(*static_cast<QStyleOptionDockWidget*>(other));
}

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_Floatable(void* ptr)
{
	return static_cast<QStyleOptionDockWidget*>(ptr)->floatable;
}

void QStyleOptionDockWidget_SetFloatable(void* ptr, char vbo)
{
	static_cast<QStyleOptionDockWidget*>(ptr)->floatable = 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_Title(void* ptr)
{
	return const_cast<char*>(static_cast<QStyleOptionDockWidget*>(ptr)->title.toUtf8().prepend("WHITESPACE").constData()+10);
}

void QStyleOptionDockWidget_SetTitle(void* ptr, char* vqs)
{
	static_cast<QStyleOptionDockWidget*>(ptr)->title = QString(vqs);
}

char QStyleOptionDockWidget_VerticalTitleBar(void* ptr)
{
	return static_cast<QStyleOptionDockWidget*>(ptr)->verticalTitleBar;
}

void QStyleOptionDockWidget_SetVerticalTitleBar(void* ptr, char vbo)
{
	static_cast<QStyleOptionDockWidget*>(ptr)->verticalTitleBar = vbo != 0;
}

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);
}

void* QStyleOptionFrame_NewQStyleOptionFrame()
{
	return new QStyleOptionFrame();
}

void* QStyleOptionFrame_NewQStyleOptionFrame2(void* other)
{
	return new QStyleOptionFrame(*static_cast<QStyleOptionFrame*>(other));
}

long long QStyleOptionFrame_Features(void* ptr)
{
	return static_cast<QStyleOptionFrame*>(ptr)->features;
}

void QStyleOptionFrame_SetFeatures(void* ptr, long long vfr)
{
	static_cast<QStyleOptionFrame*>(ptr)->features = static_cast<QStyleOptionFrame::FrameFeature>(vfr);
}

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);
}

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;
}

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);
}

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);
}

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;
}

char* QStyleOptionGroupBox_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QStyleOptionGroupBox*>(ptr)->text.toUtf8().prepend("WHITESPACE").constData()+10);
}

void QStyleOptionGroupBox_SetText(void* ptr, char* vqs)
{
	static_cast<QStyleOptionGroupBox*>(ptr)->text = QString(vqs);
}

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);
}

void* QStyleOptionHeader_NewQStyleOptionHeader()
{
	return new QStyleOptionHeader();
}

void* QStyleOptionHeader_NewQStyleOptionHeader2(void* other)
{
	return new QStyleOptionHeader(*static_cast<QStyleOptionHeader*>(other));
}

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_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);
}

long long QStyleOptionHeader_Position(void* ptr)
{
	return static_cast<QStyleOptionHeader*>(ptr)->position;
}

void QStyleOptionHeader_SetPosition(void* ptr, long long vse)
{
	static_cast<QStyleOptionHeader*>(ptr)->position = static_cast<QStyleOptionHeader::SectionPosition>(vse);
}

int QStyleOptionHeader_Section(void* ptr)
{
	return static_cast<QStyleOptionHeader*>(ptr)->section;
}

void QStyleOptionHeader_SetSection(void* ptr, int vin)
{
	static_cast<QStyleOptionHeader*>(ptr)->section = vin;
}

long long QStyleOptionHeader_SelectedPosition(void* ptr)
{
	return static_cast<QStyleOptionHeader*>(ptr)->selectedPosition;
}

void QStyleOptionHeader_SetSelectedPosition(void* ptr, long long vse)
{
	static_cast<QStyleOptionHeader*>(ptr)->selectedPosition = static_cast<QStyleOptionHeader::SelectedPosition>(vse);
}

long long QStyleOptionHeader_SortIndicator(void* ptr)
{
	return static_cast<QStyleOptionHeader*>(ptr)->sortIndicator;
}

void QStyleOptionHeader_SetSortIndicator(void* ptr, long long vso)
{
	static_cast<QStyleOptionHeader*>(ptr)->sortIndicator = static_cast<QStyleOptionHeader::SortIndicator>(vso);
}

char* QStyleOptionHeader_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QStyleOptionHeader*>(ptr)->text.toUtf8().prepend("WHITESPACE").constData()+10);
}

void QStyleOptionHeader_SetText(void* ptr, char* vqs)
{
	static_cast<QStyleOptionHeader*>(ptr)->text = QString(vqs);
}

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* QStyleOptionMenuItem_NewQStyleOptionMenuItem()
{
	return new QStyleOptionMenuItem();
}

void* QStyleOptionMenuItem_NewQStyleOptionMenuItem2(void* other)
{
	return new QStyleOptionMenuItem(*static_cast<QStyleOptionMenuItem*>(other));
}

long long QStyleOptionMenuItem_CheckType(void* ptr)
{
	return static_cast<QStyleOptionMenuItem*>(ptr)->checkType;
}

void QStyleOptionMenuItem_SetCheckType(void* ptr, long long vch)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->checkType = static_cast<QStyleOptionMenuItem::CheckType>(vch);
}

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;
}

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);
}

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;
}

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;
}

long long QStyleOptionMenuItem_MenuItemType(void* ptr)
{
	return static_cast<QStyleOptionMenuItem*>(ptr)->menuItemType;
}

void QStyleOptionMenuItem_SetMenuItemType(void* ptr, long long vme)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->menuItemType = static_cast<QStyleOptionMenuItem::MenuItemType>(vme);
}

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);
}

int QStyleOptionMenuItem_TabWidth(void* ptr)
{
	return static_cast<QStyleOptionMenuItem*>(ptr)->tabWidth;
}

void QStyleOptionMenuItem_SetTabWidth(void* ptr, int vin)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->tabWidth = vin;
}

char* QStyleOptionMenuItem_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QStyleOptionMenuItem*>(ptr)->text.toUtf8().prepend("WHITESPACE").constData()+10);
}

void QStyleOptionMenuItem_SetText(void* ptr, char* vqs)
{
	static_cast<QStyleOptionMenuItem*>(ptr)->text = QString(vqs);
}

void* QStyleOptionProgressBar_NewQStyleOptionProgressBar()
{
	return new QStyleOptionProgressBar();
}

void* QStyleOptionProgressBar_NewQStyleOptionProgressBar2(void* other)
{
	return new QStyleOptionProgressBar(*static_cast<QStyleOptionProgressBar*>(other));
}

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;
}

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;
}

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_Minimum(void* ptr)
{
	return static_cast<QStyleOptionProgressBar*>(ptr)->minimum;
}

void QStyleOptionProgressBar_SetMinimum(void* ptr, int vin)
{
	static_cast<QStyleOptionProgressBar*>(ptr)->minimum = 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;
}

char* QStyleOptionProgressBar_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QStyleOptionProgressBar*>(ptr)->text.toUtf8().prepend("WHITESPACE").constData()+10);
}

void QStyleOptionProgressBar_SetText(void* ptr, char* vqs)
{
	static_cast<QStyleOptionProgressBar*>(ptr)->text = QString(vqs);
}

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;
}

void* QStyleOptionRubberBand_NewQStyleOptionRubberBand()
{
	return new QStyleOptionRubberBand();
}

void* QStyleOptionRubberBand_NewQStyleOptionRubberBand2(void* other)
{
	return new QStyleOptionRubberBand(*static_cast<QStyleOptionRubberBand*>(other));
}

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;
}

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);
}

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);
}

void* QStyleOptionSlider_NewQStyleOptionSlider()
{
	return new QStyleOptionSlider();
}

void* QStyleOptionSlider_NewQStyleOptionSlider2(void* other)
{
	return new QStyleOptionSlider(*static_cast<QStyleOptionSlider*>(other));
}

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;
}

int QStyleOptionSlider_Maximum(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->maximum;
}

void QStyleOptionSlider_SetMaximum(void* ptr, int vin)
{
	static_cast<QStyleOptionSlider*>(ptr)->maximum = vin;
}

int QStyleOptionSlider_Minimum(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->minimum;
}

void QStyleOptionSlider_SetMinimum(void* ptr, int vin)
{
	static_cast<QStyleOptionSlider*>(ptr)->minimum = 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;
}

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_PageStep(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->pageStep;
}

void QStyleOptionSlider_SetPageStep(void* ptr, int vin)
{
	static_cast<QStyleOptionSlider*>(ptr)->pageStep = 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_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_TickInterval(void* ptr)
{
	return static_cast<QStyleOptionSlider*>(ptr)->tickInterval;
}

void QStyleOptionSlider_SetTickInterval(void* ptr, int vin)
{
	static_cast<QStyleOptionSlider*>(ptr)->tickInterval = 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);
}

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;
}

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);
}

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;
}

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);
}

void* QStyleOptionTab_NewQStyleOptionTab()
{
	return new QStyleOptionTab();
}

void* QStyleOptionTab_NewQStyleOptionTab2(void* other)
{
	return new QStyleOptionTab(*static_cast<QStyleOptionTab*>(other));
}

long long QStyleOptionTab_CornerWidgets(void* ptr)
{
	return static_cast<QStyleOptionTab*>(ptr)->cornerWidgets;
}

void QStyleOptionTab_SetCornerWidgets(void* ptr, long long vco)
{
	static_cast<QStyleOptionTab*>(ptr)->cornerWidgets = static_cast<QStyleOptionTab::CornerWidget>(vco);
}

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;
}

long long QStyleOptionTab_Features(void* ptr)
{
	return static_cast<QStyleOptionTab*>(ptr)->features;
}

void QStyleOptionTab_SetFeatures(void* ptr, long long vta)
{
	static_cast<QStyleOptionTab*>(ptr)->features = static_cast<QStyleOptionTab::TabFeature>(vta);
}

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);
}

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);
}

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);
}

long long QStyleOptionTab_Position(void* ptr)
{
	return static_cast<QStyleOptionTab*>(ptr)->position;
}

void QStyleOptionTab_SetPosition(void* ptr, long long vta)
{
	static_cast<QStyleOptionTab*>(ptr)->position = static_cast<QStyleOptionTab::TabPosition>(vta);
}

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);
}

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_SelectedPosition(void* ptr)
{
	return static_cast<QStyleOptionTab*>(ptr)->selectedPosition;
}

void QStyleOptionTab_SetSelectedPosition(void* ptr, long long vse)
{
	static_cast<QStyleOptionTab*>(ptr)->selectedPosition = static_cast<QStyleOptionTab::SelectedPosition>(vse);
}

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);
}

char* QStyleOptionTab_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QStyleOptionTab*>(ptr)->text.toUtf8().prepend("WHITESPACE").constData()+10);
}

void QStyleOptionTab_SetText(void* ptr, char* vqs)
{
	static_cast<QStyleOptionTab*>(ptr)->text = QString(vqs);
}

void* QStyleOptionTabBarBase_NewQStyleOptionTabBarBase()
{
	return new QStyleOptionTabBarBase();
}

void* QStyleOptionTabBarBase_NewQStyleOptionTabBarBase2(void* other)
{
	return new QStyleOptionTabBarBase(*static_cast<QStyleOptionTabBarBase*>(other));
}

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;
}

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);
}

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* QStyleOptionTabWidgetFrame_NewQStyleOptionTabWidgetFrame()
{
	return new QStyleOptionTabWidgetFrame();
}

void* QStyleOptionTabWidgetFrame_NewQStyleOptionTabWidgetFrame2(void* other)
{
	return new QStyleOptionTabWidgetFrame(*static_cast<QStyleOptionTabWidgetFrame*>(other));
}

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);
}

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;
}

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_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);
}

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_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_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* QStyleOptionTitleBar_NewQStyleOptionTitleBar()
{
	return new QStyleOptionTitleBar();
}

void* QStyleOptionTitleBar_NewQStyleOptionTitleBar2(void* other)
{
	return new QStyleOptionTitleBar(*static_cast<QStyleOptionTitleBar*>(other));
}

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);
}

char* QStyleOptionTitleBar_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QStyleOptionTitleBar*>(ptr)->text.toUtf8().prepend("WHITESPACE").constData()+10);
}

void QStyleOptionTitleBar_SetText(void* ptr, char* vqs)
{
	static_cast<QStyleOptionTitleBar*>(ptr)->text = QString(vqs);
}

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);
}

int QStyleOptionTitleBar_TitleBarState(void* ptr)
{
	return static_cast<QStyleOptionTitleBar*>(ptr)->titleBarState;
}

void QStyleOptionTitleBar_SetTitleBarState(void* ptr, int vin)
{
	static_cast<QStyleOptionTitleBar*>(ptr)->titleBarState = vin;
}

void* QStyleOptionToolBar_NewQStyleOptionToolBar()
{
	return new QStyleOptionToolBar();
}

void* QStyleOptionToolBar_NewQStyleOptionToolBar2(void* other)
{
	return new QStyleOptionToolBar(*static_cast<QStyleOptionToolBar*>(other));
}

long long QStyleOptionToolBar_Features(void* ptr)
{
	return static_cast<QStyleOptionToolBar*>(ptr)->features;
}

void QStyleOptionToolBar_SetFeatures(void* ptr, long long vto)
{
	static_cast<QStyleOptionToolBar*>(ptr)->features = static_cast<QStyleOptionToolBar::ToolBarFeature>(vto);
}

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;
}

long long QStyleOptionToolBar_PositionOfLine(void* ptr)
{
	return static_cast<QStyleOptionToolBar*>(ptr)->positionOfLine;
}

void QStyleOptionToolBar_SetPositionOfLine(void* ptr, long long vto)
{
	static_cast<QStyleOptionToolBar*>(ptr)->positionOfLine = static_cast<QStyleOptionToolBar::ToolBarPosition>(vto);
}

long long QStyleOptionToolBar_PositionWithinLine(void* ptr)
{
	return static_cast<QStyleOptionToolBar*>(ptr)->positionWithinLine;
}

void QStyleOptionToolBar_SetPositionWithinLine(void* ptr, long long vto)
{
	static_cast<QStyleOptionToolBar*>(ptr)->positionWithinLine = static_cast<QStyleOptionToolBar::ToolBarPosition>(vto);
}

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);
}

void* QStyleOptionToolBox_NewQStyleOptionToolBox()
{
	return new QStyleOptionToolBox();
}

void* QStyleOptionToolBox_NewQStyleOptionToolBox2(void* other)
{
	return new QStyleOptionToolBox(*static_cast<QStyleOptionToolBox*>(other));
}

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_Position(void* ptr)
{
	return static_cast<QStyleOptionToolBox*>(ptr)->position;
}

void QStyleOptionToolBox_SetPosition(void* ptr, long long vta)
{
	static_cast<QStyleOptionToolBox*>(ptr)->position = static_cast<QStyleOptionToolBox::TabPosition>(vta);
}

long long QStyleOptionToolBox_SelectedPosition(void* ptr)
{
	return static_cast<QStyleOptionToolBox*>(ptr)->selectedPosition;
}

void QStyleOptionToolBox_SetSelectedPosition(void* ptr, long long vse)
{
	static_cast<QStyleOptionToolBox*>(ptr)->selectedPosition = static_cast<QStyleOptionToolBox::SelectedPosition>(vse);
}

char* QStyleOptionToolBox_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QStyleOptionToolBox*>(ptr)->text.toUtf8().prepend("WHITESPACE").constData()+10);
}

void QStyleOptionToolBox_SetText(void* ptr, char* vqs)
{
	static_cast<QStyleOptionToolBox*>(ptr)->text = QString(vqs);
}

void* QStyleOptionToolButton_NewQStyleOptionToolButton()
{
	return new QStyleOptionToolButton();
}

void* QStyleOptionToolButton_NewQStyleOptionToolButton2(void* other)
{
	return new QStyleOptionToolButton(*static_cast<QStyleOptionToolButton*>(other));
}

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_Features(void* ptr)
{
	return static_cast<QStyleOptionToolButton*>(ptr)->features;
}

void QStyleOptionToolButton_SetFeatures(void* ptr, long long vto)
{
	static_cast<QStyleOptionToolButton*>(ptr)->features = static_cast<QStyleOptionToolButton::ToolButtonFeature>(vto);
}

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);
}

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);
}

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);
}

char* QStyleOptionToolButton_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QStyleOptionToolButton*>(ptr)->text.toUtf8().prepend("WHITESPACE").constData()+10);
}

void QStyleOptionToolButton_SetText(void* ptr, char* vqs)
{
	static_cast<QStyleOptionToolButton*>(ptr)->text = QString(vqs);
}

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* QStyleOptionViewItem_NewQStyleOptionViewItem()
{
	return new QStyleOptionViewItem();
}

void* QStyleOptionViewItem_NewQStyleOptionViewItem2(void* other)
{
	return new QStyleOptionViewItem(*static_cast<QStyleOptionViewItem*>(other));
}

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);
}

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);
}

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_DecorationPosition(void* ptr)
{
	return static_cast<QStyleOptionViewItem*>(ptr)->decorationPosition;
}

void QStyleOptionViewItem_SetDecorationPosition(void* ptr, long long vpo)
{
	static_cast<QStyleOptionViewItem*>(ptr)->decorationPosition = static_cast<QStyleOptionViewItem::Position>(vpo);
}

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);
}

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_Features(void* ptr)
{
	return static_cast<QStyleOptionViewItem*>(ptr)->features;
}

void QStyleOptionViewItem_SetFeatures(void* ptr, long long vvi)
{
	static_cast<QStyleOptionViewItem*>(ptr)->features = static_cast<QStyleOptionViewItem::ViewItemFeature>(vvi);
}

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);
}

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);
}

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);
}

void* QStyleOptionViewItem_Locale(void* ptr)
{
	return new QLocale(static_cast<QStyleOptionViewItem*>(ptr)->locale);
}

void QStyleOptionViewItem_SetLocale(void* ptr, void* vql)
{
	static_cast<QStyleOptionViewItem*>(ptr)->locale = *static_cast<QLocale*>(vql);
}

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;
}

char* QStyleOptionViewItem_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QStyleOptionViewItem*>(ptr)->text.toUtf8().prepend("WHITESPACE").constData()+10);
}

void QStyleOptionViewItem_SetText(void* ptr, char* vqs)
{
	static_cast<QStyleOptionViewItem*>(ptr)->text = QString(vqs);
}

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_ViewItemPosition(void* ptr)
{
	return static_cast<QStyleOptionViewItem*>(ptr)->viewItemPosition;
}

void QStyleOptionViewItem_SetViewItemPosition(void* ptr, long long vvi)
{
	static_cast<QStyleOptionViewItem*>(ptr)->viewItemPosition = static_cast<QStyleOptionViewItem::ViewItemPosition>(vvi);
}

void* QStyleOptionViewItem_Widget(void* ptr)
{
	return const_cast<QWidget*>(static_cast<QStyleOptionViewItem*>(ptr)->widget);
}

void* QStylePainter_NewQStylePainter()
{
	return new QStylePainter();
}

void* QStylePainter_NewQStylePainter3(void* pd, void* widget)
{
	return new QStylePainter(static_cast<QPaintDevice*>(pd), static_cast<QWidget*>(widget));
}

void* QStylePainter_NewQStylePainter2(void* widget)
{
	return new QStylePainter(static_cast<QWidget*>(widget));
}

char QStylePainter_Begin2(void* ptr, void* pd, void* widget)
{
	return static_cast<QStylePainter*>(ptr)->begin(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));
}

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, char* text, long long textRole)
{
	static_cast<QStylePainter*>(ptr)->drawItemText(*static_cast<QRect*>(rect), flags, *static_cast<QPalette*>(pal), enabled != 0, QString(text), 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();
}

class MyQStylePlugin: public QStylePlugin
{
public:
	MyQStylePlugin(QObject *parent) : QStylePlugin(parent) {};
	QStyle * create(const QString & key) { return static_cast<QStyle*>(callbackQStylePlugin_Create(this, const_cast<char*>(key.toUtf8().prepend("WHITESPACE").constData()+10))); };
	void timerEvent(QTimerEvent * event) { callbackQStylePlugin_TimerEvent(this, event); };
	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 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<MyQStylePlugin*>(this))); };
};

void* QStylePlugin_NewQStylePlugin(void* parent)
{
	return new MyQStylePlugin(static_cast<QObject*>(parent));
}

void* QStylePlugin_Create(void* ptr, char* key)
{
	return static_cast<QStylePlugin*>(ptr)->create(QString(key));
}

void QStylePlugin_DestroyQStylePlugin(void* ptr)
{
	static_cast<QStylePlugin*>(ptr)->~QStylePlugin();
}

void QStylePlugin_TimerEvent(void* ptr, void* event)
{
	static_cast<QStylePlugin*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QStylePlugin_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QStylePlugin*>(ptr)->QStylePlugin::timerEvent(static_cast<QTimerEvent*>(event));
}

void QStylePlugin_ChildEvent(void* ptr, void* event)
{
	static_cast<QStylePlugin*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QStylePlugin_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QStylePlugin*>(ptr)->QStylePlugin::childEvent(static_cast<QChildEvent*>(event));
}

void QStylePlugin_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QStylePlugin*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStylePlugin_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QStylePlugin*>(ptr)->QStylePlugin::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStylePlugin_CustomEvent(void* ptr, void* event)
{
	static_cast<QStylePlugin*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QStylePlugin_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QStylePlugin*>(ptr)->QStylePlugin::customEvent(static_cast<QEvent*>(event));
}

void QStylePlugin_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStylePlugin*>(ptr), "deleteLater");
}

void QStylePlugin_DeleteLaterDefault(void* ptr)
{
	static_cast<QStylePlugin*>(ptr)->QStylePlugin::deleteLater();
}

void QStylePlugin_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QStylePlugin*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStylePlugin_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QStylePlugin*>(ptr)->QStylePlugin::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QStylePlugin_Event(void* ptr, void* e)
{
	return static_cast<QStylePlugin*>(ptr)->event(static_cast<QEvent*>(e));
}

char QStylePlugin_EventDefault(void* ptr, void* e)
{
	return static_cast<QStylePlugin*>(ptr)->QStylePlugin::event(static_cast<QEvent*>(e));
}

char QStylePlugin_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QStylePlugin*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QStylePlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QStylePlugin*>(ptr)->QStylePlugin::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QStylePlugin_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QStylePlugin*>(ptr)->metaObject());
}

void* QStylePlugin_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QStylePlugin*>(ptr)->QStylePlugin::metaObject());
}

class MyQStyledItemDelegate: public QStyledItemDelegate
{
public:
	MyQStyledItemDelegate(QObject *parent) : QStyledItemDelegate(parent) {};
	QWidget * createEditor(QWidget * parent, const QStyleOptionViewItem & option, const QModelIndex & index) const { return static_cast<QWidget*>(callbackQStyledItemDelegate_CreateEditor(const_cast<MyQStyledItemDelegate*>(this), parent, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index))); };
	QString displayText(const QVariant & value, const QLocale & locale) const { return QString(callbackQStyledItemDelegate_DisplayText(const_cast<MyQStyledItemDelegate*>(this), const_cast<QVariant*>(&value), const_cast<QLocale*>(&locale))); };
	bool editorEvent(QEvent * event, QAbstractItemModel * model, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQStyledItemDelegate_EditorEvent(this, event, model, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)) != 0; };
	void initStyleOption(QStyleOptionViewItem * option, const QModelIndex & index) const { callbackQStyledItemDelegate_InitStyleOption(const_cast<MyQStyledItemDelegate*>(this), option, const_cast<QModelIndex*>(&index)); };
	void paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQStyledItemDelegate_Paint(const_cast<MyQStyledItemDelegate*>(this), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	void setEditorData(QWidget * editor, const QModelIndex & index) const { callbackQStyledItemDelegate_SetEditorData(const_cast<MyQStyledItemDelegate*>(this), editor, const_cast<QModelIndex*>(&index)); };
	void setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex & index) const { callbackQStyledItemDelegate_SetModelData(const_cast<MyQStyledItemDelegate*>(this), editor, model, const_cast<QModelIndex*>(&index)); };
	QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex & index) const { return *static_cast<QSize*>(callbackQStyledItemDelegate_SizeHint(const_cast<MyQStyledItemDelegate*>(this), const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index))); };
	void updateEditorGeometry(QWidget * editor, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQStyledItemDelegate_UpdateEditorGeometry(const_cast<MyQStyledItemDelegate*>(this), editor, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	void destroyEditor(QWidget * editor, const QModelIndex & index) const { callbackQStyledItemDelegate_DestroyEditor(const_cast<MyQStyledItemDelegate*>(this), editor, const_cast<QModelIndex*>(&index)); };
	bool helpEvent(QHelpEvent * event, QAbstractItemView * view, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQStyledItemDelegate_HelpEvent(this, event, view, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)) != 0; };
	void timerEvent(QTimerEvent * event) { callbackQStyledItemDelegate_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQStyledItemDelegate_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQStyledItemDelegate_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQStyledItemDelegate_CustomEvent(this, event); };
	void deleteLater() { callbackQStyledItemDelegate_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQStyledItemDelegate_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool event(QEvent * e) { return callbackQStyledItemDelegate_Event(this, e) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStyledItemDelegate_MetaObject(const_cast<MyQStyledItemDelegate*>(this))); };
};

char QStyledItemDelegate_EventFilter(void* ptr, void* editor, void* event)
{
	return static_cast<QStyledItemDelegate*>(ptr)->eventFilter(static_cast<QObject*>(editor), static_cast<QEvent*>(event));
}

void* QStyledItemDelegate_NewQStyledItemDelegate(void* parent)
{
	return new MyQStyledItemDelegate(static_cast<QObject*>(parent));
}

void* QStyledItemDelegate_CreateEditor(void* ptr, void* parent, void* option, void* index)
{
	return static_cast<QStyledItemDelegate*>(ptr)->createEditor(static_cast<QWidget*>(parent), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void* QStyledItemDelegate_CreateEditorDefault(void* ptr, void* parent, void* option, void* index)
{
	return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::createEditor(static_cast<QWidget*>(parent), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

char* QStyledItemDelegate_DisplayText(void* ptr, void* value, void* locale)
{
	return const_cast<char*>(static_cast<QStyledItemDelegate*>(ptr)->displayText(*static_cast<QVariant*>(value), *static_cast<QLocale*>(locale)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QStyledItemDelegate_DisplayTextDefault(void* ptr, void* value, void* locale)
{
	return const_cast<char*>(static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::displayText(*static_cast<QVariant*>(value), *static_cast<QLocale*>(locale)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char QStyledItemDelegate_EditorEvent(void* ptr, void* event, void* model, void* option, void* index)
{
	return static_cast<QStyledItemDelegate*>(ptr)->editorEvent(static_cast<QEvent*>(event), static_cast<QAbstractItemModel*>(model), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

char QStyledItemDelegate_EditorEventDefault(void* ptr, void* event, void* model, void* option, void* index)
{
	return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::editorEvent(static_cast<QEvent*>(event), static_cast<QAbstractItemModel*>(model), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

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_SetEditorData(void* ptr, void* editor, void* index)
{
	static_cast<QStyledItemDelegate*>(ptr)->setEditorData(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
}

void QStyledItemDelegate_SetEditorDataDefault(void* ptr, void* editor, void* index)
{
	static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::setEditorData(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
}

void QStyledItemDelegate_SetItemEditorFactory(void* ptr, void* factory)
{
	static_cast<QStyledItemDelegate*>(ptr)->setItemEditorFactory(static_cast<QItemEditorFactory*>(factory));
}

void QStyledItemDelegate_SetModelData(void* ptr, void* editor, void* model, void* index)
{
	static_cast<QStyledItemDelegate*>(ptr)->setModelData(static_cast<QWidget*>(editor), static_cast<QAbstractItemModel*>(model), *static_cast<QModelIndex*>(index));
}

void QStyledItemDelegate_SetModelDataDefault(void* ptr, void* editor, void* model, void* index)
{
	static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::setModelData(static_cast<QWidget*>(editor), static_cast<QAbstractItemModel*>(model), *static_cast<QModelIndex*>(index));
}

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_UpdateEditorGeometry(void* ptr, void* editor, void* option, void* index)
{
	static_cast<QStyledItemDelegate*>(ptr)->updateEditorGeometry(static_cast<QWidget*>(editor), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QStyledItemDelegate_UpdateEditorGeometryDefault(void* ptr, void* editor, void* option, void* index)
{
	static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::updateEditorGeometry(static_cast<QWidget*>(editor), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QStyledItemDelegate_DestroyQStyledItemDelegate(void* ptr)
{
	static_cast<QStyledItemDelegate*>(ptr)->~QStyledItemDelegate();
}

void QStyledItemDelegate_DestroyEditor(void* ptr, void* editor, void* index)
{
	static_cast<QStyledItemDelegate*>(ptr)->destroyEditor(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
}

void QStyledItemDelegate_DestroyEditorDefault(void* ptr, void* editor, void* index)
{
	static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::destroyEditor(static_cast<QWidget*>(editor), *static_cast<QModelIndex*>(index));
}

char QStyledItemDelegate_HelpEvent(void* ptr, void* event, void* view, void* option, void* index)
{
	return static_cast<QStyledItemDelegate*>(ptr)->helpEvent(static_cast<QHelpEvent*>(event), static_cast<QAbstractItemView*>(view), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

char QStyledItemDelegate_HelpEventDefault(void* ptr, void* event, void* view, void* option, void* index)
{
	return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::helpEvent(static_cast<QHelpEvent*>(event), static_cast<QAbstractItemView*>(view), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QStyledItemDelegate_TimerEvent(void* ptr, void* event)
{
	static_cast<QStyledItemDelegate*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QStyledItemDelegate_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::timerEvent(static_cast<QTimerEvent*>(event));
}

void QStyledItemDelegate_ChildEvent(void* ptr, void* event)
{
	static_cast<QStyledItemDelegate*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QStyledItemDelegate_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::childEvent(static_cast<QChildEvent*>(event));
}

void QStyledItemDelegate_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QStyledItemDelegate*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStyledItemDelegate_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStyledItemDelegate_CustomEvent(void* ptr, void* event)
{
	static_cast<QStyledItemDelegate*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QStyledItemDelegate_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::customEvent(static_cast<QEvent*>(event));
}

void QStyledItemDelegate_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QStyledItemDelegate*>(ptr), "deleteLater");
}

void QStyledItemDelegate_DeleteLaterDefault(void* ptr)
{
	static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::deleteLater();
}

void QStyledItemDelegate_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QStyledItemDelegate*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStyledItemDelegate_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QStyledItemDelegate_Event(void* ptr, void* e)
{
	return static_cast<QStyledItemDelegate*>(ptr)->event(static_cast<QEvent*>(e));
}

char QStyledItemDelegate_EventDefault(void* ptr, void* e)
{
	return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::event(static_cast<QEvent*>(e));
}

void* QStyledItemDelegate_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QStyledItemDelegate*>(ptr)->metaObject());
}

void* QStyledItemDelegate_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::metaObject());
}

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_TimerEvent(void* ptr, void* event)
{
	static_cast<QSwipeGesture*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QSwipeGesture_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::timerEvent(static_cast<QTimerEvent*>(event));
}

void QSwipeGesture_ChildEvent(void* ptr, void* event)
{
	static_cast<QSwipeGesture*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QSwipeGesture_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::childEvent(static_cast<QChildEvent*>(event));
}

void QSwipeGesture_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QSwipeGesture*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSwipeGesture_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSwipeGesture_CustomEvent(void* ptr, void* event)
{
	static_cast<QSwipeGesture*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QSwipeGesture_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::customEvent(static_cast<QEvent*>(event));
}

void QSwipeGesture_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSwipeGesture*>(ptr), "deleteLater");
}

void QSwipeGesture_DeleteLaterDefault(void* ptr)
{
	static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::deleteLater();
}

void QSwipeGesture_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QSwipeGesture*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSwipeGesture_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QSwipeGesture_Event(void* ptr, void* e)
{
	return static_cast<QSwipeGesture*>(ptr)->event(static_cast<QEvent*>(e));
}

char QSwipeGesture_EventDefault(void* ptr, void* e)
{
	return static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::event(static_cast<QEvent*>(e));
}

char QSwipeGesture_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QSwipeGesture*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QSwipeGesture_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QSwipeGesture_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSwipeGesture*>(ptr)->metaObject());
}

void* QSwipeGesture_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::metaObject());
}

class MyQSystemTrayIcon: public QSystemTrayIcon
{
public:
	MyQSystemTrayIcon(QObject *parent) : QSystemTrayIcon(parent) {};
	MyQSystemTrayIcon(const QIcon &icon, QObject *parent) : QSystemTrayIcon(icon, parent) {};
	void setVisible(bool visible) { callbackQSystemTrayIcon_SetVisible(this, visible); };
	void showMessage(const QString & title, const QString & message, QSystemTrayIcon::MessageIcon icon, int millisecondsTimeoutHint) { callbackQSystemTrayIcon_ShowMessage(this, const_cast<char*>(title.toUtf8().prepend("WHITESPACE").constData()+10), const_cast<char*>(message.toUtf8().prepend("WHITESPACE").constData()+10), icon, millisecondsTimeoutHint); };
	void Signal_Activated(QSystemTrayIcon::ActivationReason reason) { callbackQSystemTrayIcon_Activated(this, reason); };
	void hide() { callbackQSystemTrayIcon_Hide(this); };
	void Signal_MessageClicked() { callbackQSystemTrayIcon_MessageClicked(this); };
	void show() { callbackQSystemTrayIcon_Show(this); };
	void timerEvent(QTimerEvent * event) { callbackQSystemTrayIcon_TimerEvent(this, event); };
	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 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<MyQSystemTrayIcon*>(this))); };
};

void* QSystemTrayIcon_Icon(void* ptr)
{
	return new QIcon(static_cast<QSystemTrayIcon*>(ptr)->icon());
}

char QSystemTrayIcon_IsVisible(void* ptr)
{
	return static_cast<QSystemTrayIcon*>(ptr)->isVisible();
}

void QSystemTrayIcon_SetIcon(void* ptr, void* icon)
{
	static_cast<QSystemTrayIcon*>(ptr)->setIcon(*static_cast<QIcon*>(icon));
}

void QSystemTrayIcon_SetToolTip(void* ptr, char* tip)
{
	static_cast<QSystemTrayIcon*>(ptr)->setToolTip(QString(tip));
}

void QSystemTrayIcon_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QSystemTrayIcon*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QSystemTrayIcon_ShowMessage(void* ptr, char* title, char* message, long long icon, int millisecondsTimeoutHint)
{
	QMetaObject::invokeMethod(static_cast<QSystemTrayIcon*>(ptr), "showMessage", Q_ARG(QString, QString(title)), Q_ARG(QString, QString(message)), Q_ARG(QSystemTrayIcon::MessageIcon, static_cast<QSystemTrayIcon::MessageIcon>(icon)), Q_ARG(int, millisecondsTimeoutHint));
}

char* QSystemTrayIcon_ToolTip(void* ptr)
{
	return const_cast<char*>(static_cast<QSystemTrayIcon*>(ptr)->toolTip().toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QSystemTrayIcon_NewQSystemTrayIcon(void* parent)
{
	return new MyQSystemTrayIcon(static_cast<QObject*>(parent));
}

void* QSystemTrayIcon_NewQSystemTrayIcon2(void* icon, void* parent)
{
	return new MyQSystemTrayIcon(*static_cast<QIcon*>(icon), static_cast<QObject*>(parent));
}

void QSystemTrayIcon_ConnectActivated(void* ptr)
{
	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));
}

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_Event(void* ptr, void* e)
{
	return static_cast<QSystemTrayIcon*>(ptr)->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");
}

char QSystemTrayIcon_QSystemTrayIcon_IsSystemTrayAvailable()
{
	return QSystemTrayIcon::isSystemTrayAvailable();
}

void QSystemTrayIcon_ConnectMessageClicked(void* ptr)
{
	QObject::connect(static_cast<QSystemTrayIcon*>(ptr), static_cast<void (QSystemTrayIcon::*)()>(&QSystemTrayIcon::messageClicked), static_cast<MyQSystemTrayIcon*>(ptr), static_cast<void (MyQSystemTrayIcon::*)()>(&MyQSystemTrayIcon::Signal_MessageClicked));
}

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_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSystemTrayIcon*>(ptr), "show");
}

char QSystemTrayIcon_QSystemTrayIcon_SupportsMessages()
{
	return QSystemTrayIcon::supportsMessages();
}

void QSystemTrayIcon_DestroyQSystemTrayIcon(void* ptr)
{
	static_cast<QSystemTrayIcon*>(ptr)->~QSystemTrayIcon();
}

void QSystemTrayIcon_TimerEvent(void* ptr, void* event)
{
	static_cast<QSystemTrayIcon*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QSystemTrayIcon_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::timerEvent(static_cast<QTimerEvent*>(event));
}

void QSystemTrayIcon_ChildEvent(void* ptr, void* event)
{
	static_cast<QSystemTrayIcon*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QSystemTrayIcon_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::childEvent(static_cast<QChildEvent*>(event));
}

void QSystemTrayIcon_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QSystemTrayIcon*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSystemTrayIcon_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSystemTrayIcon_CustomEvent(void* ptr, void* event)
{
	static_cast<QSystemTrayIcon*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QSystemTrayIcon_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::customEvent(static_cast<QEvent*>(event));
}

void QSystemTrayIcon_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSystemTrayIcon*>(ptr), "deleteLater");
}

void QSystemTrayIcon_DeleteLaterDefault(void* ptr)
{
	static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::deleteLater();
}

void QSystemTrayIcon_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QSystemTrayIcon*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSystemTrayIcon_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QSystemTrayIcon_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QSystemTrayIcon*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QSystemTrayIcon_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QSystemTrayIcon_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSystemTrayIcon*>(ptr)->metaObject());
}

void* QSystemTrayIcon_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QSystemTrayIcon*>(ptr)->QSystemTrayIcon::metaObject());
}

class MyQTabBar: public QTabBar
{
public:
	MyQTabBar(QWidget *parent) : QTabBar(parent) {};
	void setCurrentIndex(int index) { callbackQTabBar_SetCurrentIndex(this, index); };
	void changeEvent(QEvent * event) { callbackQTabBar_ChangeEvent(this, event); };
	void Signal_CurrentChanged(int index) { callbackQTabBar_CurrentChanged(this, index); };
	void hideEvent(QHideEvent * vqh) { callbackQTabBar_HideEvent(this, vqh); };
	void keyPressEvent(QKeyEvent * event) { callbackQTabBar_KeyPressEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTabBar_MinimumSizeHint(const_cast<MyQTabBar*>(this))); };
	QSize minimumTabSizeHint(int index) const { return *static_cast<QSize*>(callbackQTabBar_MinimumTabSizeHint(const_cast<MyQTabBar*>(this), index)); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQTabBar_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQTabBar_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQTabBar_MouseReleaseEvent(this, event); };
	void paintEvent(QPaintEvent * vqp) { callbackQTabBar_PaintEvent(this, vqp); };
	void resizeEvent(QResizeEvent * vqr) { callbackQTabBar_ResizeEvent(this, vqr); };
	void showEvent(QShowEvent * vqs) { callbackQTabBar_ShowEvent(this, vqs); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQTabBar_SizeHint(const_cast<MyQTabBar*>(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<MyQTabBar*>(this), index)); };
	void wheelEvent(QWheelEvent * event) { callbackQTabBar_WheelEvent(this, event); };
	void actionEvent(QActionEvent * event) { callbackQTabBar_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQTabBar_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQTabBar_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQTabBar_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQTabBar_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQTabBar_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQTabBar_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQTabBar_FocusOutEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQTabBar_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQTabBar_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQTabBar_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQTabBar_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQTabBar_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQTabBar_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQTabBar_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQTabBar_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQTabBar_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQTabBar_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQTabBar_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQTabBar_HasHeightForWidth(const_cast<MyQTabBar*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQTabBar_HeightForWidth(const_cast<MyQTabBar*>(this), w); };
	void hide() { callbackQTabBar_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQTabBar_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQTabBar_InputMethodQuery(const_cast<MyQTabBar*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQTabBar_KeyReleaseEvent(this, event); };
	void lower() { callbackQTabBar_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQTabBar_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTabBar_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQTabBar_Raise(this); };
	void repaint() { callbackQTabBar_Repaint(this); };
	void setDisabled(bool disable) { callbackQTabBar_SetDisabled(this, disable); };
	void setFocus() { callbackQTabBar_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQTabBar_SetHidden(this, hidden); };
	void show() { callbackQTabBar_Show(this); };
	void showFullScreen() { callbackQTabBar_ShowFullScreen(this); };
	void showMaximized() { callbackQTabBar_ShowMaximized(this); };
	void showMinimized() { callbackQTabBar_ShowMinimized(this); };
	void showNormal() { callbackQTabBar_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQTabBar_TabletEvent(this, event); };
	void update() { callbackQTabBar_Update(this); };
	void updateMicroFocus() { callbackQTabBar_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQTabBar_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTabBar_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTabBar_CustomEvent(this, event); };
	void deleteLater() { callbackQTabBar_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTabBar_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTabBar_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTabBar_MetaObject(const_cast<MyQTabBar*>(this))); };
};

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();
}

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()); });
}

char QTabBar_IsMovable(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->isMovable();
}

long long QTabBar_SelectionBehaviorOnRemove(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->selectionBehaviorOnRemove();
}

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_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_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();
}

char QTabBar_TabsClosable(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->tabsClosable();
}

char QTabBar_UsesScrollButtons(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->usesScrollButtons();
}

void* QTabBar_NewQTabBar(void* parent)
{
	return new MyQTabBar(static_cast<QWidget*>(parent));
}

int QTabBar_AddTab2(void* ptr, void* icon, char* text)
{
	return static_cast<QTabBar*>(ptr)->addTab(*static_cast<QIcon*>(icon), QString(text));
}

int QTabBar_AddTab(void* ptr, char* text)
{
	return static_cast<QTabBar*>(ptr)->addTab(QString(text));
}

void QTabBar_ChangeEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QTabBar_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::changeEvent(static_cast<QEvent*>(event));
}

void QTabBar_ConnectCurrentChanged(void* ptr)
{
	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));
}

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);
}

char QTabBar_Event(void* ptr, void* event)
{
	return static_cast<QTabBar*>(ptr)->event(static_cast<QEvent*>(event));
}

void QTabBar_HideEvent(void* ptr, void* vqh)
{
	static_cast<QTabBar*>(ptr)->hideEvent(static_cast<QHideEvent*>(vqh));
}

void QTabBar_HideEventDefault(void* ptr, void* vqh)
{
	static_cast<QTabBar*>(ptr)->QTabBar::hideEvent(static_cast<QHideEvent*>(vqh));
}

void QTabBar_InitStyleOption(void* ptr, void* option, int tabIndex)
{
	static_cast<QTabBar*>(ptr)->initStyleOption(static_cast<QStyleOptionTab*>(option), tabIndex);
}

int QTabBar_InsertTab2(void* ptr, int index, void* icon, char* text)
{
	return static_cast<QTabBar*>(ptr)->insertTab(index, *static_cast<QIcon*>(icon), QString(text));
}

int QTabBar_InsertTab(void* ptr, int index, char* text)
{
	return static_cast<QTabBar*>(ptr)->insertTab(index, QString(text));
}

char QTabBar_IsTabEnabled(void* ptr, int index)
{
	return static_cast<QTabBar*>(ptr)->isTabEnabled(index);
}

void QTabBar_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QTabBar_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void* QTabBar_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTabBar*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTabBar_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTabBar*>(ptr)->QTabBar::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTabBar_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTabBar_MousePressEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTabBar_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTabBar_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QTabBar_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QTabBar_MoveTab(void* ptr, int from, int to)
{
	static_cast<QTabBar*>(ptr)->moveTab(from, to);
}

void QTabBar_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QTabBar*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QTabBar_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QTabBar*>(ptr)->QTabBar::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QTabBar_RemoveTab(void* ptr, int index)
{
	static_cast<QTabBar*>(ptr)->removeTab(index);
}

void QTabBar_ResizeEvent(void* ptr, void* vqr)
{
	static_cast<QTabBar*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(vqr));
}

void QTabBar_ResizeEventDefault(void* ptr, void* vqr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::resizeEvent(static_cast<QResizeEvent*>(vqr));
}

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, char* text)
{
	static_cast<QTabBar*>(ptr)->setTabText(index, QString(text));
}

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, char* tip)
{
	static_cast<QTabBar*>(ptr)->setTabToolTip(index, QString(tip));
}

void QTabBar_SetTabWhatsThis(void* ptr, int index, char* text)
{
	static_cast<QTabBar*>(ptr)->setTabWhatsThis(index, QString(text));
}

void QTabBar_ShowEvent(void* ptr, void* vqs)
{
	static_cast<QTabBar*>(ptr)->showEvent(static_cast<QShowEvent*>(vqs));
}

void QTabBar_ShowEventDefault(void* ptr, void* vqs)
{
	static_cast<QTabBar*>(ptr)->QTabBar::showEvent(static_cast<QShowEvent*>(vqs));
}

void* QTabBar_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTabBar*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTabBar_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTabBar*>(ptr)->QTabBar::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QTabBar_TabAt(void* ptr, void* position)
{
	return static_cast<QTabBar*>(ptr)->tabAt(*static_cast<QPoint*>(position));
}

void QTabBar_ConnectTabBarClicked(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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()); });
}

char* QTabBar_TabText(void* ptr, int index)
{
	return const_cast<char*>(static_cast<QTabBar*>(ptr)->tabText(index).toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QTabBar_TabTextColor(void* ptr, int index)
{
	return new QColor(static_cast<QTabBar*>(ptr)->tabTextColor(index));
}

char* QTabBar_TabToolTip(void* ptr, int index)
{
	return const_cast<char*>(static_cast<QTabBar*>(ptr)->tabToolTip(index).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QTabBar_TabWhatsThis(void* ptr, int index)
{
	return const_cast<char*>(static_cast<QTabBar*>(ptr)->tabWhatsThis(index).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QTabBar_TimerEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QTabBar_WheelEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QTabBar_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QTabBar_DestroyQTabBar(void* ptr)
{
	static_cast<QTabBar*>(ptr)->~QTabBar();
}

void QTabBar_ActionEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QTabBar_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::actionEvent(static_cast<QActionEvent*>(event));
}

void QTabBar_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTabBar_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTabBar_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QTabBar_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QTabBar_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QTabBar_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QTabBar_DropEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QTabBar_DropEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::dropEvent(static_cast<QDropEvent*>(event));
}

void QTabBar_EnterEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QTabBar_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::enterEvent(static_cast<QEvent*>(event));
}

void QTabBar_FocusInEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QTabBar_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QTabBar_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTabBar_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTabBar_LeaveEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QTabBar_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::leaveEvent(static_cast<QEvent*>(event));
}

void QTabBar_MoveEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QTabBar_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::moveEvent(static_cast<QMoveEvent*>(event));
}

void QTabBar_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QTabBar_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QTabBar*>(ptr)->QTabBar::setEnabled(vbo != 0);
}

void QTabBar_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QTabBar_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QTabBar*>(ptr)->QTabBar::setStyleSheet(QString(styleSheet));
}

void QTabBar_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QTabBar_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QTabBar*>(ptr)->QTabBar::setVisible(visible != 0);
}

void QTabBar_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QTabBar_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QTabBar*>(ptr)->QTabBar::setWindowModified(vbo != 0);
}

void QTabBar_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QTabBar_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QTabBar*>(ptr)->QTabBar::setWindowTitle(QString(vqs));
}

char QTabBar_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QTabBar_CloseDefault(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->QTabBar::close();
}

void QTabBar_CloseEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QTabBar_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::closeEvent(static_cast<QCloseEvent*>(event));
}

void QTabBar_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QTabBar_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QTabBar_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QTabBar*>(ptr)->focusNextPrevChild(next != 0);
}

char QTabBar_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QTabBar*>(ptr)->QTabBar::focusNextPrevChild(next != 0);
}

char QTabBar_HasHeightForWidth(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->hasHeightForWidth();
}

char QTabBar_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QTabBar*>(ptr)->QTabBar::hasHeightForWidth();
}

int QTabBar_HeightForWidth(void* ptr, int w)
{
	return static_cast<QTabBar*>(ptr)->heightForWidth(w);
}

int QTabBar_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QTabBar*>(ptr)->QTabBar::heightForWidth(w);
}

void QTabBar_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "hide");
}

void QTabBar_HideDefault(void* ptr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::hide();
}

void QTabBar_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QTabBar_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QTabBar_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QTabBar*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QTabBar_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QTabBar*>(ptr)->QTabBar::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QTabBar_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QTabBar_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QTabBar_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "lower");
}

void QTabBar_LowerDefault(void* ptr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::lower();
}

void QTabBar_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QTabBar_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QTabBar_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTabBar*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QTabBar_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTabBar*>(ptr)->QTabBar::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QTabBar_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "raise");
}

void QTabBar_RaiseDefault(void* ptr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::raise();
}

void QTabBar_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "repaint");
}

void QTabBar_RepaintDefault(void* ptr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::repaint();
}

void QTabBar_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QTabBar_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QTabBar*>(ptr)->QTabBar::setDisabled(disable != 0);
}

void QTabBar_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setFocus");
}

void QTabBar_SetFocus2Default(void* ptr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::setFocus();
}

void QTabBar_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QTabBar_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QTabBar*>(ptr)->QTabBar::setHidden(hidden != 0);
}

void QTabBar_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "show");
}

void QTabBar_ShowDefault(void* ptr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::show();
}

void QTabBar_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "showFullScreen");
}

void QTabBar_ShowFullScreenDefault(void* ptr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::showFullScreen();
}

void QTabBar_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "showMaximized");
}

void QTabBar_ShowMaximizedDefault(void* ptr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::showMaximized();
}

void QTabBar_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "showMinimized");
}

void QTabBar_ShowMinimizedDefault(void* ptr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::showMinimized();
}

void QTabBar_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "showNormal");
}

void QTabBar_ShowNormalDefault(void* ptr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::showNormal();
}

void QTabBar_TabletEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTabBar_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTabBar_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "update");
}

void QTabBar_UpdateDefault(void* ptr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::update();
}

void QTabBar_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "updateMicroFocus");
}

void QTabBar_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::updateMicroFocus();
}

void QTabBar_ChildEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QTabBar_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::childEvent(static_cast<QChildEvent*>(event));
}

void QTabBar_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QTabBar*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTabBar_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTabBar*>(ptr)->QTabBar::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTabBar_CustomEvent(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QTabBar_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QTabBar*>(ptr)->QTabBar::customEvent(static_cast<QEvent*>(event));
}

void QTabBar_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "deleteLater");
}

void QTabBar_DeleteLaterDefault(void* ptr)
{
	static_cast<QTabBar*>(ptr)->QTabBar::deleteLater();
}

void QTabBar_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QTabBar*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTabBar_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTabBar*>(ptr)->QTabBar::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QTabBar_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QTabBar*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QTabBar_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QTabBar*>(ptr)->QTabBar::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QTabBar_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTabBar*>(ptr)->metaObject());
}

void* QTabBar_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTabBar*>(ptr)->QTabBar::metaObject());
}

class MyQTabWidget: public QTabWidget
{
public:
	MyQTabWidget(QWidget *parent) : QTabWidget(parent) {};
	void paintEvent(QPaintEvent * event) { callbackQTabWidget_PaintEvent(this, event); };
	void setCurrentIndex(int index) { callbackQTabWidget_SetCurrentIndex(this, index); };
	void changeEvent(QEvent * ev) { callbackQTabWidget_ChangeEvent(this, ev); };
	void Signal_CurrentChanged(int index) { callbackQTabWidget_CurrentChanged(this, index); };
	bool hasHeightForWidth() const { return callbackQTabWidget_HasHeightForWidth(const_cast<MyQTabWidget*>(this)) != 0; };
	int heightForWidth(int width) const { return callbackQTabWidget_HeightForWidth(const_cast<MyQTabWidget*>(this), width); };
	void keyPressEvent(QKeyEvent * e) { callbackQTabWidget_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTabWidget_MinimumSizeHint(const_cast<MyQTabWidget*>(this))); };
	void resizeEvent(QResizeEvent * e) { callbackQTabWidget_ResizeEvent(this, e); };
	void setCurrentWidget(QWidget * widget) { callbackQTabWidget_SetCurrentWidget(this, widget); };
	void showEvent(QShowEvent * vqs) { callbackQTabWidget_ShowEvent(this, vqs); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQTabWidget_SizeHint(const_cast<MyQTabWidget*>(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); };
	void actionEvent(QActionEvent * event) { callbackQTabWidget_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQTabWidget_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQTabWidget_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQTabWidget_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQTabWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQTabWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQTabWidget_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQTabWidget_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQTabWidget_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQTabWidget_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQTabWidget_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQTabWidget_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQTabWidget_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQTabWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQTabWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQTabWidget_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQTabWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQTabWidget_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQTabWidget_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQTabWidget_FocusNextPrevChild(this, next) != 0; };
	void hide() { callbackQTabWidget_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQTabWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQTabWidget_InputMethodQuery(const_cast<MyQTabWidget*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQTabWidget_KeyReleaseEvent(this, event); };
	void lower() { callbackQTabWidget_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQTabWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQTabWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQTabWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQTabWidget_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTabWidget_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQTabWidget_Raise(this); };
	void repaint() { callbackQTabWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQTabWidget_SetDisabled(this, disable); };
	void setFocus() { callbackQTabWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQTabWidget_SetHidden(this, hidden); };
	void show() { callbackQTabWidget_Show(this); };
	void showFullScreen() { callbackQTabWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQTabWidget_ShowMaximized(this); };
	void showMinimized() { callbackQTabWidget_ShowMinimized(this); };
	void showNormal() { callbackQTabWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQTabWidget_TabletEvent(this, event); };
	void update() { callbackQTabWidget_Update(this); };
	void updateMicroFocus() { callbackQTabWidget_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQTabWidget_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQTabWidget_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQTabWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTabWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTabWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQTabWidget_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTabWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTabWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTabWidget_MetaObject(const_cast<MyQTabWidget*>(this))); };
};

int QTabWidget_AddTab2(void* ptr, void* page, void* icon, char* label)
{
	return static_cast<QTabWidget*>(ptr)->addTab(static_cast<QWidget*>(page), *static_cast<QIcon*>(icon), QString(label));
}

int QTabWidget_AddTab(void* ptr, void* page, char* label)
{
	return static_cast<QTabWidget*>(ptr)->addTab(static_cast<QWidget*>(page), QString(label));
}

int QTabWidget_Count(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->count();
}

int QTabWidget_CurrentIndex(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->currentIndex();
}

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_InsertTab2(void* ptr, int index, void* page, void* icon, char* label)
{
	return static_cast<QTabWidget*>(ptr)->insertTab(index, static_cast<QWidget*>(page), *static_cast<QIcon*>(icon), QString(label));
}

int QTabWidget_InsertTab(void* ptr, int index, void* page, char* label)
{
	return static_cast<QTabWidget*>(ptr)->insertTab(index, static_cast<QWidget*>(page), QString(label));
}

char QTabWidget_IsMovable(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->isMovable();
}

void QTabWidget_PaintEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QTabWidget_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::paintEvent(static_cast<QPaintEvent*>(event));
}

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_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_SetTabBarAutoHide(void* ptr, char enabled)
{
	static_cast<QTabWidget*>(ptr)->setTabBarAutoHide(enabled != 0);
}

void QTabWidget_SetTabPosition(void* ptr, long long vta)
{
	static_cast<QTabWidget*>(ptr)->setTabPosition(static_cast<QTabWidget::TabPosition>(vta));
}

void QTabWidget_SetTabShape(void* ptr, long long s)
{
	static_cast<QTabWidget*>(ptr)->setTabShape(static_cast<QTabWidget::TabShape>(s));
}

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);
}

char QTabWidget_TabBarAutoHide(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->tabBarAutoHide();
}

long long QTabWidget_TabPosition(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->tabPosition();
}

long long QTabWidget_TabShape(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->tabShape();
}

char QTabWidget_TabsClosable(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->tabsClosable();
}

char QTabWidget_UsesScrollButtons(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->usesScrollButtons();
}

void* QTabWidget_NewQTabWidget(void* parent)
{
	return new MyQTabWidget(static_cast<QWidget*>(parent));
}

void QTabWidget_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QTabWidget*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QTabWidget_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::changeEvent(static_cast<QEvent*>(ev));
}

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));
}

void QTabWidget_ConnectCurrentChanged(void* ptr)
{
	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));
}

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);
}

void* QTabWidget_CurrentWidget(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->currentWidget();
}

char QTabWidget_Event(void* ptr, void* ev)
{
	return static_cast<QTabWidget*>(ptr)->event(static_cast<QEvent*>(ev));
}

char QTabWidget_HasHeightForWidth(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->hasHeightForWidth();
}

char QTabWidget_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->QTabWidget::hasHeightForWidth();
}

int QTabWidget_HeightForWidth(void* ptr, int width)
{
	return static_cast<QTabWidget*>(ptr)->heightForWidth(width);
}

int QTabWidget_HeightForWidthDefault(void* ptr, int width)
{
	return static_cast<QTabWidget*>(ptr)->QTabWidget::heightForWidth(width);
}

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));
}

char QTabWidget_IsTabEnabled(void* ptr, int index)
{
	return static_cast<QTabWidget*>(ptr)->isTabEnabled(index);
}

void QTabWidget_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QTabWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QTabWidget_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void* QTabWidget_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTabWidget*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTabWidget_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTabWidget*>(ptr)->QTabWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTabWidget_RemoveTab(void* ptr, int index)
{
	static_cast<QTabWidget*>(ptr)->removeTab(index);
}

void QTabWidget_ResizeEvent(void* ptr, void* e)
{
	static_cast<QTabWidget*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(e));
}

void QTabWidget_ResizeEventDefault(void* ptr, void* e)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::resizeEvent(static_cast<QResizeEvent*>(e));
}

void QTabWidget_SetCurrentWidget(void* ptr, void* widget)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setCurrentWidget", Q_ARG(QWidget*, static_cast<QWidget*>(widget)));
}

void QTabWidget_SetTabBar(void* ptr, void* tb)
{
	static_cast<QTabWidget*>(ptr)->setTabBar(static_cast<QTabBar*>(tb));
}

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_SetTabText(void* ptr, int index, char* label)
{
	static_cast<QTabWidget*>(ptr)->setTabText(index, QString(label));
}

void QTabWidget_SetTabToolTip(void* ptr, int index, char* tip)
{
	static_cast<QTabWidget*>(ptr)->setTabToolTip(index, QString(tip));
}

void QTabWidget_SetTabWhatsThis(void* ptr, int index, char* text)
{
	static_cast<QTabWidget*>(ptr)->setTabWhatsThis(index, QString(text));
}

void QTabWidget_ShowEvent(void* ptr, void* vqs)
{
	static_cast<QTabWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(vqs));
}

void QTabWidget_ShowEventDefault(void* ptr, void* vqs)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::showEvent(static_cast<QShowEvent*>(vqs));
}

void* QTabWidget_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTabWidget*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTabWidget_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTabWidget*>(ptr)->QTabWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTabWidget_TabBar(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->tabBar();
}

void QTabWidget_ConnectTabBarClicked(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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);
}

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);
}

char* QTabWidget_TabText(void* ptr, int index)
{
	return const_cast<char*>(static_cast<QTabWidget*>(ptr)->tabText(index).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QTabWidget_TabToolTip(void* ptr, int index)
{
	return const_cast<char*>(static_cast<QTabWidget*>(ptr)->tabToolTip(index).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QTabWidget_TabWhatsThis(void* ptr, int index)
{
	return const_cast<char*>(static_cast<QTabWidget*>(ptr)->tabWhatsThis(index).toUtf8().prepend("WHITESPACE").constData()+10);
}

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_ActionEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QTabWidget_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::actionEvent(static_cast<QActionEvent*>(event));
}

void QTabWidget_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTabWidget_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTabWidget_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QTabWidget_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QTabWidget_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QTabWidget_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QTabWidget_DropEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QTabWidget_DropEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::dropEvent(static_cast<QDropEvent*>(event));
}

void QTabWidget_EnterEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QTabWidget_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::enterEvent(static_cast<QEvent*>(event));
}

void QTabWidget_FocusInEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QTabWidget_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QTabWidget_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTabWidget_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTabWidget_HideEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QTabWidget_HideEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::hideEvent(static_cast<QHideEvent*>(event));
}

void QTabWidget_LeaveEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QTabWidget_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::leaveEvent(static_cast<QEvent*>(event));
}

void QTabWidget_MoveEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QTabWidget_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::moveEvent(static_cast<QMoveEvent*>(event));
}

void QTabWidget_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QTabWidget_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::setEnabled(vbo != 0);
}

void QTabWidget_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QTabWidget_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::setStyleSheet(QString(styleSheet));
}

void QTabWidget_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QTabWidget_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::setVisible(visible != 0);
}

void QTabWidget_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QTabWidget_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::setWindowModified(vbo != 0);
}

void QTabWidget_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QTabWidget_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::setWindowTitle(QString(vqs));
}

char QTabWidget_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QTabWidget_CloseDefault(void* ptr)
{
	return static_cast<QTabWidget*>(ptr)->QTabWidget::close();
}

void QTabWidget_CloseEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QTabWidget_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::closeEvent(static_cast<QCloseEvent*>(event));
}

void QTabWidget_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QTabWidget_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QTabWidget_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QTabWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QTabWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QTabWidget*>(ptr)->QTabWidget::focusNextPrevChild(next != 0);
}

void QTabWidget_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "hide");
}

void QTabWidget_HideDefault(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::hide();
}

void QTabWidget_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QTabWidget_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QTabWidget_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QTabWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QTabWidget_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QTabWidget*>(ptr)->QTabWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QTabWidget_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QTabWidget_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QTabWidget_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "lower");
}

void QTabWidget_LowerDefault(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::lower();
}

void QTabWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QTabWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QTabWidget_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTabWidget_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTabWidget_MousePressEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTabWidget_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTabWidget_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QTabWidget_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QTabWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTabWidget*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QTabWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTabWidget*>(ptr)->QTabWidget::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QTabWidget_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "raise");
}

void QTabWidget_RaiseDefault(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::raise();
}

void QTabWidget_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "repaint");
}

void QTabWidget_RepaintDefault(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::repaint();
}

void QTabWidget_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QTabWidget_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::setDisabled(disable != 0);
}

void QTabWidget_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setFocus");
}

void QTabWidget_SetFocus2Default(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::setFocus();
}

void QTabWidget_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QTabWidget_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::setHidden(hidden != 0);
}

void QTabWidget_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "show");
}

void QTabWidget_ShowDefault(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::show();
}

void QTabWidget_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "showFullScreen");
}

void QTabWidget_ShowFullScreenDefault(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::showFullScreen();
}

void QTabWidget_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "showMaximized");
}

void QTabWidget_ShowMaximizedDefault(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::showMaximized();
}

void QTabWidget_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "showMinimized");
}

void QTabWidget_ShowMinimizedDefault(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::showMinimized();
}

void QTabWidget_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "showNormal");
}

void QTabWidget_ShowNormalDefault(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::showNormal();
}

void QTabWidget_TabletEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTabWidget_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTabWidget_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "update");
}

void QTabWidget_UpdateDefault(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::update();
}

void QTabWidget_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "updateMicroFocus");
}

void QTabWidget_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::updateMicroFocus();
}

void QTabWidget_WheelEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QTabWidget_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QTabWidget_TimerEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QTabWidget_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::timerEvent(static_cast<QTimerEvent*>(event));
}

void QTabWidget_ChildEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QTabWidget_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::childEvent(static_cast<QChildEvent*>(event));
}

void QTabWidget_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QTabWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTabWidget_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTabWidget_CustomEvent(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QTabWidget_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::customEvent(static_cast<QEvent*>(event));
}

void QTabWidget_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "deleteLater");
}

void QTabWidget_DeleteLaterDefault(void* ptr)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::deleteLater();
}

void QTabWidget_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QTabWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTabWidget_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTabWidget*>(ptr)->QTabWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QTabWidget_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QTabWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QTabWidget_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QTabWidget*>(ptr)->QTabWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QTabWidget_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTabWidget*>(ptr)->metaObject());
}

void* QTabWidget_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTabWidget*>(ptr)->QTabWidget::metaObject());
}

class MyQTableView: public QTableView
{
public:
	MyQTableView(QWidget *parent) : QTableView(parent) {};
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQTableView_MoveCursor(this, cursorAction, modifiers)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags flags) { callbackQTableView_SetSelection(this, const_cast<QRect*>(&rect), flags); };
	void setShowGrid(bool show) { callbackQTableView_SetShowGrid(this, show); };
	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<MyQTableView*>(this)); };
	QModelIndex indexAt(const QPoint & pos) const { return *static_cast<QModelIndex*>(callbackQTableView_IndexAt(const_cast<MyQTableView*>(this), const_cast<QPoint*>(&pos))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQTableView_IsIndexHidden(const_cast<MyQTableView*>(this), const_cast<QModelIndex*>(&index)) != 0; };
	void paintEvent(QPaintEvent * event) { callbackQTableView_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); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQTableView_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	void setModel(QAbstractItemModel * model) { callbackQTableView_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQTableView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQTableView_SetSelectionModel(this, selectionModel); };
	void showColumn(int column) { callbackQTableView_ShowColumn(this, column); };
	void showRow(int row) { callbackQTableView_ShowRow(this, row); };
	int sizeHintForColumn(int column) const { return callbackQTableView_SizeHintForColumn(const_cast<MyQTableView*>(this), column); };
	int sizeHintForRow(int row) const { return callbackQTableView_SizeHintForRow(const_cast<MyQTableView*>(this), row); };
	void updateGeometries() { callbackQTableView_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQTableView_VerticalOffset(const_cast<MyQTableView*>(this)); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQTableView_ViewOptions(const_cast<MyQTableView*>(this))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQTableView_ViewportSizeHint(const_cast<MyQTableView*>(this))); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQTableView_DragLeaveEvent(this, event); };
	bool viewportEvent(QEvent * event) { return callbackQTableView_ViewportEvent(this, event) != 0; };
	void clearSelection() { callbackQTableView_ClearSelection(this); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQTableView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQTableView_CommitData(this, editor); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQTableView_DragEnterEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQTableView_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQTableView_DropEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQTableView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQTableView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQTableView_EditorDestroyed(this, editor); };
	void focusInEvent(QFocusEvent * event) { callbackQTableView_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQTableView_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQTableView_FocusOutEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQTableView_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQTableView_InputMethodQuery(const_cast<MyQTableView*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQTableView_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { callbackQTableView_KeyboardSearch(this, const_cast<char*>(search.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQTableView_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQTableView_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQTableView_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQTableView_MouseReleaseEvent(this, event); };
	void reset() { callbackQTableView_Reset(this); };
	void resizeEvent(QResizeEvent * event) { callbackQTableView_ResizeEvent(this, event); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQTableView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQTableView_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() { callbackQTableView_ScrollToBottom(this); };
	void scrollToTop() { callbackQTableView_ScrollToTop(this); };
	void selectAll() { callbackQTableView_SelectAll(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQTableView_SelectionCommand(const_cast<MyQTableView*>(this), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQTableView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	void startDrag(Qt::DropActions supportedActions) { callbackQTableView_StartDrag(this, supportedActions); };
	void update(const QModelIndex & index) { callbackQTableView_Update(this, const_cast<QModelIndex*>(&index)); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQTableView_VisualRect(const_cast<MyQTableView*>(this), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQTableView_VisualRegionForSelection(const_cast<MyQTableView*>(this), const_cast<QItemSelection*>(&selection))); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQTableView_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTableView_MinimumSizeHint(const_cast<MyQTableView*>(this))); };
	void scrollContentsBy(int dx, int dy) { callbackQTableView_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQTableView_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQTableView_SizeHint(const_cast<MyQTableView*>(this))); };
	void wheelEvent(QWheelEvent * e) { callbackQTableView_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQTableView_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQTableView_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQTableView_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQTableView_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQTableView_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQTableView_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQTableView_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQTableView_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQTableView_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQTableView_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQTableView_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQTableView_ShowEvent(this, event); };
	bool close() { return callbackQTableView_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQTableView_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQTableView_HasHeightForWidth(const_cast<MyQTableView*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQTableView_HeightForWidth(const_cast<MyQTableView*>(this), w); };
	void hide() { callbackQTableView_Hide(this); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQTableView_KeyReleaseEvent(this, event); };
	void lower() { callbackQTableView_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTableView_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQTableView_Raise(this); };
	void repaint() { callbackQTableView_Repaint(this); };
	void setDisabled(bool disable) { callbackQTableView_SetDisabled(this, disable); };
	void setFocus() { callbackQTableView_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQTableView_SetHidden(this, hidden); };
	void show() { callbackQTableView_Show(this); };
	void showFullScreen() { callbackQTableView_ShowFullScreen(this); };
	void showMaximized() { callbackQTableView_ShowMaximized(this); };
	void showMinimized() { callbackQTableView_ShowMinimized(this); };
	void showNormal() { callbackQTableView_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQTableView_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQTableView_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQTableView_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTableView_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTableView_CustomEvent(this, event); };
	void deleteLater() { callbackQTableView_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTableView_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTableView_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTableView_MetaObject(const_cast<MyQTableView*>(this))); };
};

long long QTableView_GridStyle(void* ptr)
{
	return static_cast<QTableView*>(ptr)->gridStyle();
}

char QTableView_IsCornerButtonEnabled(void* ptr)
{
	return static_cast<QTableView*>(ptr)->isCornerButtonEnabled();
}

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)
{
	return new QModelIndex(static_cast<QTableView*>(ptr)->QTableView::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

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_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)
{
	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_SetSpan(void* ptr, int row, int column, int rowSpanCount, int columnSpanCount)
{
	static_cast<QTableView*>(ptr)->setSpan(row, column, rowSpanCount, columnSpanCount);
}

void QTableView_SetWordWrap(void* ptr, char on)
{
	static_cast<QTableView*>(ptr)->setWordWrap(on != 0);
}

char QTableView_ShowGrid(void* ptr)
{
	return static_cast<QTableView*>(ptr)->showGrid();
}

char QTableView_WordWrap(void* ptr)
{
	return static_cast<QTableView*>(ptr)->wordWrap();
}

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_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_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));
}

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)
{
	static_cast<QTableView*>(ptr)->QTableView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QTableView_HideColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "hideColumn", Q_ARG(int, column));
}

void QTableView_HideRow(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "hideRow", Q_ARG(int, row));
}

int QTableView_HorizontalOffset(void* ptr)
{
	return static_cast<QTableView*>(ptr)->horizontalOffset();
}

int QTableView_HorizontalOffsetDefault(void* ptr)
{
	return static_cast<QTableView*>(ptr)->QTableView::horizontalOffset();
}

void* QTableView_HorizontalHeader(void* ptr)
{
	return static_cast<QTableView*>(ptr)->horizontalHeader();
}

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)
{
	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_IsIndexHidden(void* ptr, void* index)
{
	return static_cast<QTableView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}

char QTableView_IsIndexHiddenDefault(void* ptr, void* index)
{
	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);
}

void QTableView_PaintEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QTableView_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::paintEvent(static_cast<QPaintEvent*>(event));
}

void QTableView_ResizeColumnToContents(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "resizeColumnToContents", Q_ARG(int, column));
}

void QTableView_ResizeColumnsToContents(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "resizeColumnsToContents");
}

void QTableView_ResizeRowToContents(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "resizeRowToContents", Q_ARG(int, row));
}

void QTableView_ResizeRowsToContents(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "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));
}

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_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));
}

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_SelectRow(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "selectRow", Q_ARG(int, 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)
{
	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_SetHorizontalHeader(void* ptr, void* header)
{
	static_cast<QTableView*>(ptr)->setHorizontalHeader(static_cast<QHeaderView*>(header));
}

void QTableView_SetModel(void* ptr, void* model)
{
	static_cast<QTableView*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}

void QTableView_SetModelDefault(void* ptr, void* model)
{
	static_cast<QTableView*>(ptr)->QTableView::setModel(static_cast<QAbstractItemModel*>(model));
}

void QTableView_SetRootIndex(void* ptr, void* index)
{
	static_cast<QTableView*>(ptr)->setRootIndex(*static_cast<QModelIndex*>(index));
}

void QTableView_SetRootIndexDefault(void* ptr, void* index)
{
	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_SetSelectionModel(void* ptr, void* selectionModel)
{
	static_cast<QTableView*>(ptr)->setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

void QTableView_SetSelectionModelDefault(void* ptr, void* selectionModel)
{
	static_cast<QTableView*>(ptr)->QTableView::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

void QTableView_SetSortingEnabled(void* ptr, char enable)
{
	static_cast<QTableView*>(ptr)->setSortingEnabled(enable != 0);
}

void QTableView_SetVerticalHeader(void* ptr, void* header)
{
	static_cast<QTableView*>(ptr)->setVerticalHeader(static_cast<QHeaderView*>(header));
}

void QTableView_ShowColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "showColumn", Q_ARG(int, column));
}

void QTableView_ShowRow(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "showRow", Q_ARG(int, row));
}

int QTableView_SizeHintForColumn(void* ptr, int column)
{
	return static_cast<QTableView*>(ptr)->sizeHintForColumn(column);
}

int QTableView_SizeHintForColumnDefault(void* ptr, int column)
{
	return static_cast<QTableView*>(ptr)->QTableView::sizeHintForColumn(column);
}

int QTableView_SizeHintForRow(void* ptr, int row)
{
	return static_cast<QTableView*>(ptr)->sizeHintForRow(row);
}

int QTableView_SizeHintForRowDefault(void* ptr, int row)
{
	return static_cast<QTableView*>(ptr)->QTableView::sizeHintForRow(row);
}

void QTableView_SortByColumn(void* ptr, int column, long long order)
{
	static_cast<QTableView*>(ptr)->sortByColumn(column, static_cast<Qt::SortOrder>(order));
}

void QTableView_TimerEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QTableView_UpdateGeometries(void* ptr)
{
	static_cast<QTableView*>(ptr)->updateGeometries();
}

void QTableView_UpdateGeometriesDefault(void* ptr)
{
	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)
{
	return static_cast<QTableView*>(ptr)->QTableView::verticalOffset();
}

void* QTableView_ViewOptions(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QTableView*>(ptr)->viewOptions());
}

void* QTableView_ViewOptionsDefault(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QTableView*>(ptr)->QTableView::viewOptions());
}

void* QTableView_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableView*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTableView_ViewportSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableView*>(ptr)->QTableView::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTableView_DestroyQTableView(void* ptr)
{
	static_cast<QTableView*>(ptr)->~QTableView();
}

void QTableView_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QTableView_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

char QTableView_ViewportEvent(void* ptr, void* event)
{
	return static_cast<QTableView*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}

char QTableView_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QTableView*>(ptr)->QTableView::viewportEvent(static_cast<QEvent*>(event));
}

void QTableView_ClearSelection(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "clearSelection");
}

void QTableView_ClearSelectionDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::clearSelection();
}

void QTableView_CloseEditor(void* ptr, void* editor, long long hint)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "closeEditor", Q_ARG(QWidget*, static_cast<QWidget*>(editor)), Q_ARG(QAbstractItemDelegate::EndEditHint, static_cast<QAbstractItemDelegate::EndEditHint>(hint)));
}

void QTableView_CloseEditorDefault(void* ptr, void* editor, long long hint)
{
	static_cast<QTableView*>(ptr)->QTableView::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
}

void QTableView_CommitData(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "commitData", Q_ARG(QWidget*, static_cast<QWidget*>(editor)));
}

void QTableView_CommitDataDefault(void* ptr, void* editor)
{
	static_cast<QTableView*>(ptr)->QTableView::commitData(static_cast<QWidget*>(editor));
}

void QTableView_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTableView_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTableView_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QTableView_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QTableView_DropEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QTableView_DropEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::dropEvent(static_cast<QDropEvent*>(event));
}

void QTableView_Edit(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "edit", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTableView_EditDefault(void* ptr, void* index)
{
	static_cast<QTableView*>(ptr)->QTableView::edit(*static_cast<QModelIndex*>(index));
}

char QTableView_Edit2(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QTableView*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

char QTableView_Edit2Default(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QTableView*>(ptr)->QTableView::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

void QTableView_EditorDestroyed(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "editorDestroyed", Q_ARG(QObject*, static_cast<QObject*>(editor)));
}

void QTableView_EditorDestroyedDefault(void* ptr, void* editor)
{
	static_cast<QTableView*>(ptr)->QTableView::editorDestroyed(static_cast<QObject*>(editor));
}

void QTableView_FocusInEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QTableView_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QTableView_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QTableView*>(ptr)->focusNextPrevChild(next != 0);
}

char QTableView_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QTableView*>(ptr)->QTableView::focusNextPrevChild(next != 0);
}

void QTableView_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTableView_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTableView_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QTableView_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QTableView_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QTableView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QTableView_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QTableView*>(ptr)->QTableView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QTableView_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QTableView_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QTableView_KeyboardSearch(void* ptr, char* search)
{
	static_cast<QTableView*>(ptr)->keyboardSearch(QString(search));
}

void QTableView_KeyboardSearchDefault(void* ptr, char* search)
{
	static_cast<QTableView*>(ptr)->QTableView::keyboardSearch(QString(search));
}

void QTableView_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QTableView_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QTableView_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTableView_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTableView_MousePressEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTableView_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTableView_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QTableView_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QTableView_Reset(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "reset");
}

void QTableView_ResetDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::reset();
}

void QTableView_ResizeEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QTableView_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QTableView_RowsAboutToBeRemoved(void* ptr, void* parent, int start, int end)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "rowsAboutToBeRemoved", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
}

void QTableView_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QTableView*>(ptr)->QTableView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
}

void QTableView_RowsInserted(void* ptr, void* parent, int start, int end)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "rowsInserted", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
}

void QTableView_RowsInsertedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QTableView*>(ptr)->QTableView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
}

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)
{
	static_cast<QTableView*>(ptr)->QTableView::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QTableView_ScrollToBottom(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "scrollToBottom");
}

void QTableView_ScrollToBottomDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::scrollToBottom();
}

void QTableView_ScrollToTop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "scrollToTop");
}

void QTableView_ScrollToTopDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::scrollToTop();
}

void QTableView_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "selectAll");
}

void QTableView_SelectAllDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::selectAll();
}

long long QTableView_SelectionCommand(void* ptr, void* index, void* event)
{
	return static_cast<QTableView*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

long long QTableView_SelectionCommandDefault(void* ptr, void* index, void* event)
{
	return static_cast<QTableView*>(ptr)->QTableView::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

void QTableView_SetCurrentIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setCurrentIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTableView_SetCurrentIndexDefault(void* ptr, void* index)
{
	static_cast<QTableView*>(ptr)->QTableView::setCurrentIndex(*static_cast<QModelIndex*>(index));
}

void QTableView_StartDrag(void* ptr, long long supportedActions)
{
	static_cast<QTableView*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QTableView_StartDragDefault(void* ptr, long long supportedActions)
{
	static_cast<QTableView*>(ptr)->QTableView::startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QTableView_Update(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "update", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTableView_UpdateDefault(void* ptr, void* index)
{
	static_cast<QTableView*>(ptr)->QTableView::update(*static_cast<QModelIndex*>(index));
}

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)
{
	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)
{
	return new QRegion(static_cast<QTableView*>(ptr)->QTableView::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void QTableView_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QTableView*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QTableView_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QTableView*>(ptr)->QTableView::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void* QTableView_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableView*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTableView_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableView*>(ptr)->QTableView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTableView_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QTableView*>(ptr)->scrollContentsBy(dx, dy);
}

void QTableView_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QTableView*>(ptr)->QTableView::scrollContentsBy(dx, dy);
}

void QTableView_SetupViewport(void* ptr, void* viewport)
{
	static_cast<QTableView*>(ptr)->setupViewport(static_cast<QWidget*>(viewport));
}

void QTableView_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QTableView*>(ptr)->QTableView::setupViewport(static_cast<QWidget*>(viewport));
}

void* QTableView_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableView*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTableView_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableView*>(ptr)->QTableView::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTableView_WheelEvent(void* ptr, void* e)
{
	static_cast<QTableView*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QTableView_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QTableView*>(ptr)->QTableView::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QTableView_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QTableView*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QTableView_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QTableView*>(ptr)->QTableView::changeEvent(static_cast<QEvent*>(ev));
}

void QTableView_ActionEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QTableView_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::actionEvent(static_cast<QActionEvent*>(event));
}

void QTableView_EnterEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QTableView_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::enterEvent(static_cast<QEvent*>(event));
}

void QTableView_HideEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QTableView_HideEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::hideEvent(static_cast<QHideEvent*>(event));
}

void QTableView_LeaveEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QTableView_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::leaveEvent(static_cast<QEvent*>(event));
}

void QTableView_MoveEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QTableView_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::moveEvent(static_cast<QMoveEvent*>(event));
}

void QTableView_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QTableView_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QTableView*>(ptr)->QTableView::setEnabled(vbo != 0);
}

void QTableView_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QTableView_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QTableView*>(ptr)->QTableView::setStyleSheet(QString(styleSheet));
}

void QTableView_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QTableView_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QTableView*>(ptr)->QTableView::setVisible(visible != 0);
}

void QTableView_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QTableView_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QTableView*>(ptr)->QTableView::setWindowModified(vbo != 0);
}

void QTableView_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QTableView_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QTableView*>(ptr)->QTableView::setWindowTitle(QString(vqs));
}

void QTableView_ShowEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QTableView_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::showEvent(static_cast<QShowEvent*>(event));
}

char QTableView_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QTableView_CloseDefault(void* ptr)
{
	return static_cast<QTableView*>(ptr)->QTableView::close();
}

void QTableView_CloseEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QTableView_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::closeEvent(static_cast<QCloseEvent*>(event));
}

char QTableView_HasHeightForWidth(void* ptr)
{
	return static_cast<QTableView*>(ptr)->hasHeightForWidth();
}

char QTableView_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QTableView*>(ptr)->QTableView::hasHeightForWidth();
}

int QTableView_HeightForWidth(void* ptr, int w)
{
	return static_cast<QTableView*>(ptr)->heightForWidth(w);
}

int QTableView_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QTableView*>(ptr)->QTableView::heightForWidth(w);
}

void QTableView_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "hide");
}

void QTableView_HideDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::hide();
}

void QTableView_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QTableView_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QTableView_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "lower");
}

void QTableView_LowerDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::lower();
}

char QTableView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTableView*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QTableView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTableView*>(ptr)->QTableView::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QTableView_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "raise");
}

void QTableView_RaiseDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::raise();
}

void QTableView_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "repaint");
}

void QTableView_RepaintDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::repaint();
}

void QTableView_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QTableView_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QTableView*>(ptr)->QTableView::setDisabled(disable != 0);
}

void QTableView_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setFocus");
}

void QTableView_SetFocus2Default(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::setFocus();
}

void QTableView_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QTableView_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QTableView*>(ptr)->QTableView::setHidden(hidden != 0);
}

void QTableView_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "show");
}

void QTableView_ShowDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::show();
}

void QTableView_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "showFullScreen");
}

void QTableView_ShowFullScreenDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::showFullScreen();
}

void QTableView_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "showMaximized");
}

void QTableView_ShowMaximizedDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::showMaximized();
}

void QTableView_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "showMinimized");
}

void QTableView_ShowMinimizedDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::showMinimized();
}

void QTableView_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "showNormal");
}

void QTableView_ShowNormalDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::showNormal();
}

void QTableView_TabletEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTableView_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTableView_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "updateMicroFocus");
}

void QTableView_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::updateMicroFocus();
}

void QTableView_ChildEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QTableView_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::childEvent(static_cast<QChildEvent*>(event));
}

void QTableView_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QTableView*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTableView_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTableView*>(ptr)->QTableView::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTableView_CustomEvent(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QTableView_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QTableView*>(ptr)->QTableView::customEvent(static_cast<QEvent*>(event));
}

void QTableView_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "deleteLater");
}

void QTableView_DeleteLaterDefault(void* ptr)
{
	static_cast<QTableView*>(ptr)->QTableView::deleteLater();
}

void QTableView_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QTableView*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTableView_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTableView*>(ptr)->QTableView::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QTableView_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QTableView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QTableView_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QTableView*>(ptr)->QTableView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QTableView_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTableView*>(ptr)->metaObject());
}

void* QTableView_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTableView*>(ptr)->QTableView::metaObject());
}

class MyQTableWidget: public QTableWidget
{
public:
	MyQTableWidget(QWidget *parent) : QTableWidget(parent) {};
	MyQTableWidget(int rows, int columns, QWidget *parent) : QTableWidget(rows, columns, parent) {};
	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) { callbackQTableWidget_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; };
	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); };
	QStringList mimeTypes() const { return QString(callbackQTableWidget_MimeTypes(const_cast<MyQTableWidget*>(this))).split("|", QString::SkipEmptyParts); };
	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<MyQTableWidget*>(this))); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQTableWidget_MoveCursor(this, cursorAction, modifiers)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags flags) { callbackQTableWidget_SetSelection(this, const_cast<QRect*>(&rect), flags); };
	void setShowGrid(bool show) { callbackQTableWidget_SetShowGrid(this, show); };
	void columnCountChanged(int oldCount, int newCount) { callbackQTableWidget_ColumnCountChanged(this, oldCount, newCount); };
	void columnMoved(int column, int oldIndex, int newIndex) { callbackQTableWidget_ColumnMoved(this, column, oldIndex, newIndex); };
	void columnResized(int column, int oldWidth, int newWidth) { callbackQTableWidget_ColumnResized(this, column, oldWidth, newWidth); };
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQTableWidget_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	void hideColumn(int column) { callbackQTableWidget_HideColumn(this, column); };
	void hideRow(int row) { callbackQTableWidget_HideRow(this, row); };
	int horizontalOffset() const { return callbackQTableWidget_HorizontalOffset(const_cast<MyQTableWidget*>(this)); };
	QModelIndex indexAt(const QPoint & pos) const { return *static_cast<QModelIndex*>(callbackQTableWidget_IndexAt(const_cast<MyQTableWidget*>(this), const_cast<QPoint*>(&pos))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQTableWidget_IsIndexHidden(const_cast<MyQTableWidget*>(this), const_cast<QModelIndex*>(&index)) != 0; };
	void paintEvent(QPaintEvent * event) { callbackQTableWidget_PaintEvent(this, event); };
	void resizeColumnToContents(int column) { callbackQTableWidget_ResizeColumnToContents(this, column); };
	void resizeColumnsToContents() { callbackQTableWidget_ResizeColumnsToContents(this); };
	void resizeRowToContents(int row) { callbackQTableWidget_ResizeRowToContents(this, row); };
	void resizeRowsToContents() { callbackQTableWidget_ResizeRowsToContents(this); };
	void rowCountChanged(int oldCount, int newCount) { callbackQTableWidget_RowCountChanged(this, oldCount, newCount); };
	void rowMoved(int row, int oldIndex, int newIndex) { callbackQTableWidget_RowMoved(this, row, oldIndex, newIndex); };
	void rowResized(int row, int oldHeight, int newHeight) { callbackQTableWidget_RowResized(this, row, oldHeight, newHeight); };
	void selectColumn(int column) { callbackQTableWidget_SelectColumn(this, column); };
	void selectRow(int row) { callbackQTableWidget_SelectRow(this, row); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQTableWidget_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	void setModel(QAbstractItemModel * model) { callbackQTableWidget_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQTableWidget_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQTableWidget_SetSelectionModel(this, selectionModel); };
	void showColumn(int column) { callbackQTableWidget_ShowColumn(this, column); };
	void showRow(int row) { callbackQTableWidget_ShowRow(this, row); };
	int sizeHintForColumn(int column) const { return callbackQTableWidget_SizeHintForColumn(const_cast<MyQTableWidget*>(this), column); };
	int sizeHintForRow(int row) const { return callbackQTableWidget_SizeHintForRow(const_cast<MyQTableWidget*>(this), row); };
	void updateGeometries() { callbackQTableWidget_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQTableWidget_VerticalOffset(const_cast<MyQTableWidget*>(this)); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQTableWidget_ViewOptions(const_cast<MyQTableWidget*>(this))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQTableWidget_ViewportSizeHint(const_cast<MyQTableWidget*>(this))); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQTableWidget_DragLeaveEvent(this, event); };
	bool viewportEvent(QEvent * event) { return callbackQTableWidget_ViewportEvent(this, event) != 0; };
	void clearSelection() { callbackQTableWidget_ClearSelection(this); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQTableWidget_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQTableWidget_CommitData(this, editor); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQTableWidget_DragEnterEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQTableWidget_DragMoveEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQTableWidget_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQTableWidget_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQTableWidget_EditorDestroyed(this, editor); };
	void focusInEvent(QFocusEvent * event) { callbackQTableWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQTableWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQTableWidget_FocusOutEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQTableWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQTableWidget_InputMethodQuery(const_cast<MyQTableWidget*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQTableWidget_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { callbackQTableWidget_KeyboardSearch(this, const_cast<char*>(search.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQTableWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQTableWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQTableWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQTableWidget_MouseReleaseEvent(this, event); };
	void reset() { callbackQTableWidget_Reset(this); };
	void resizeEvent(QResizeEvent * event) { callbackQTableWidget_ResizeEvent(this, event); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQTableWidget_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQTableWidget_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQTableWidget_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	void scrollToBottom() { callbackQTableWidget_ScrollToBottom(this); };
	void scrollToTop() { callbackQTableWidget_ScrollToTop(this); };
	void selectAll() { callbackQTableWidget_SelectAll(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQTableWidget_SelectionCommand(const_cast<MyQTableWidget*>(this), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQTableWidget_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	void startDrag(Qt::DropActions supportedActions) { callbackQTableWidget_StartDrag(this, supportedActions); };
	void update(const QModelIndex & index) { callbackQTableWidget_Update(this, const_cast<QModelIndex*>(&index)); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQTableWidget_VisualRect(const_cast<MyQTableWidget*>(this), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQTableWidget_VisualRegionForSelection(const_cast<MyQTableWidget*>(this), const_cast<QItemSelection*>(&selection))); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQTableWidget_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTableWidget_MinimumSizeHint(const_cast<MyQTableWidget*>(this))); };
	void scrollContentsBy(int dx, int dy) { callbackQTableWidget_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQTableWidget_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQTableWidget_SizeHint(const_cast<MyQTableWidget*>(this))); };
	void wheelEvent(QWheelEvent * e) { callbackQTableWidget_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQTableWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQTableWidget_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQTableWidget_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQTableWidget_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQTableWidget_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQTableWidget_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQTableWidget_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQTableWidget_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQTableWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQTableWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQTableWidget_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQTableWidget_ShowEvent(this, event); };
	bool close() { return callbackQTableWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQTableWidget_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQTableWidget_HasHeightForWidth(const_cast<MyQTableWidget*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQTableWidget_HeightForWidth(const_cast<MyQTableWidget*>(this), w); };
	void hide() { callbackQTableWidget_Hide(this); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQTableWidget_KeyReleaseEvent(this, event); };
	void lower() { callbackQTableWidget_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTableWidget_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQTableWidget_Raise(this); };
	void repaint() { callbackQTableWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQTableWidget_SetDisabled(this, disable); };
	void setFocus() { callbackQTableWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQTableWidget_SetHidden(this, hidden); };
	void show() { callbackQTableWidget_Show(this); };
	void showFullScreen() { callbackQTableWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQTableWidget_ShowMaximized(this); };
	void showMinimized() { callbackQTableWidget_ShowMinimized(this); };
	void showNormal() { callbackQTableWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQTableWidget_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQTableWidget_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQTableWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTableWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTableWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQTableWidget_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTableWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTableWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTableWidget_MetaObject(const_cast<MyQTableWidget*>(this))); };
};

void* QTableWidget_ItemAt(void* ptr, void* point)
{
	return static_cast<QTableWidget*>(ptr)->itemAt(*static_cast<QPoint*>(point));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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_ClearContents(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "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)
{
	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));
}

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)
{
	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));
}

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();
}

void QTableWidget_DropEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QTableWidget_DropEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::dropEvent(static_cast<QDropEvent*>(event));
}

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));
}

char QTableWidget_Event(void* ptr, void* e)
{
	return static_cast<QTableWidget*>(ptr)->event(static_cast<QEvent*>(e));
}

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_InsertRow(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "insertRow", Q_ARG(int, row));
}

void* QTableWidget_Item(void* ptr, int row, int column)
{
	return static_cast<QTableWidget*>(ptr)->item(row, column);
}

void QTableWidget_ConnectItemActivated(void* ptr)
{
	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));
}

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_ItemAt2(void* ptr, int ax, int ay)
{
	return static_cast<QTableWidget*>(ptr)->itemAt(ax, ay);
}

void QTableWidget_ConnectItemChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	QObject::connect(static_cast<QTableWidget*>(ptr), static_cast<void (QTableWidget::*)()>(&QTableWidget::itemSelectionChanged), static_cast<MyQTableWidget*>(ptr), static_cast<void (MyQTableWidget::*)()>(&MyQTableWidget::Signal_ItemSelectionChanged));
}

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();
}

char* QTableWidget_MimeTypes(void* ptr)
{
	return const_cast<char*>(static_cast<QTableWidget*>(ptr)->mimeTypes().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QTableWidget_MimeTypesDefault(void* ptr)
{
	return const_cast<char*>(static_cast<QTableWidget*>(ptr)->QTableWidget::mimeTypes().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

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_RemoveRow(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "removeRow", Q_ARG(int, 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)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "scrollToItem", Q_ARG(QTableWidgetItem*, static_cast<QTableWidgetItem*>(item)), Q_ARG(QAbstractItemView::ScrollHint, static_cast<QAbstractItemView::ScrollHint>(hint)));
}

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, char* labels)
{
	static_cast<QTableWidget*>(ptr)->setHorizontalHeaderLabels(QString(labels).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, char* labels)
{
	static_cast<QTableWidget*>(ptr)->setVerticalHeaderLabels(QString(labels).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_MoveCursor(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QTableWidget*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void* QTableWidget_MoveCursorDefault(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QTableWidget*>(ptr)->QTableWidget::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void QTableWidget_SetSelection(void* ptr, void* rect, long long flags)
{
	static_cast<QTableWidget*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
}

void QTableWidget_SetSelectionDefault(void* ptr, void* rect, long long flags)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
}

void QTableWidget_SetShowGrid(void* ptr, char show)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setShowGrid", Q_ARG(bool, show != 0));
}

void QTableWidget_SetShowGridDefault(void* ptr, char show)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setShowGrid(show != 0);
}

void QTableWidget_ColumnCountChanged(void* ptr, int oldCount, int newCount)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "columnCountChanged", Q_ARG(int, oldCount), Q_ARG(int, newCount));
}

void QTableWidget_ColumnCountChangedDefault(void* ptr, int oldCount, int newCount)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::columnCountChanged(oldCount, newCount);
}

void QTableWidget_ColumnMoved(void* ptr, int column, int oldIndex, int newIndex)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "columnMoved", Q_ARG(int, column), Q_ARG(int, oldIndex), Q_ARG(int, newIndex));
}

void QTableWidget_ColumnMovedDefault(void* ptr, int column, int oldIndex, int newIndex)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::columnMoved(column, oldIndex, newIndex);
}

void QTableWidget_ColumnResized(void* ptr, int column, int oldWidth, int newWidth)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "columnResized", Q_ARG(int, column), Q_ARG(int, oldWidth), Q_ARG(int, newWidth));
}

void QTableWidget_ColumnResizedDefault(void* ptr, int column, int oldWidth, int newWidth)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::columnResized(column, oldWidth, newWidth);
}

void QTableWidget_CurrentChanged(void* ptr, void* current, void* previous)
{
	static_cast<QTableWidget*>(ptr)->currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QTableWidget_CurrentChangedDefault(void* ptr, void* current, void* previous)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QTableWidget_HideColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "hideColumn", Q_ARG(int, column));
}

void QTableWidget_HideColumnDefault(void* ptr, int column)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::hideColumn(column);
}

void QTableWidget_HideRow(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "hideRow", Q_ARG(int, row));
}

void QTableWidget_HideRowDefault(void* ptr, int row)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::hideRow(row);
}

int QTableWidget_HorizontalOffset(void* ptr)
{
	return static_cast<QTableWidget*>(ptr)->horizontalOffset();
}

int QTableWidget_HorizontalOffsetDefault(void* ptr)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::horizontalOffset();
}

void* QTableWidget_IndexAt(void* ptr, void* pos)
{
	return new QModelIndex(static_cast<QTableWidget*>(ptr)->indexAt(*static_cast<QPoint*>(pos)));
}

void* QTableWidget_IndexAtDefault(void* ptr, void* pos)
{
	return new QModelIndex(static_cast<QTableWidget*>(ptr)->QTableWidget::indexAt(*static_cast<QPoint*>(pos)));
}

char QTableWidget_IsIndexHidden(void* ptr, void* index)
{
	return static_cast<QTableWidget*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}

char QTableWidget_IsIndexHiddenDefault(void* ptr, void* index)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::isIndexHidden(*static_cast<QModelIndex*>(index));
}

void QTableWidget_PaintEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QTableWidget_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::paintEvent(static_cast<QPaintEvent*>(event));
}

void QTableWidget_ResizeColumnToContents(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "resizeColumnToContents", Q_ARG(int, column));
}

void QTableWidget_ResizeColumnToContentsDefault(void* ptr, int column)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::resizeColumnToContents(column);
}

void QTableWidget_ResizeColumnsToContents(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "resizeColumnsToContents");
}

void QTableWidget_ResizeColumnsToContentsDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::resizeColumnsToContents();
}

void QTableWidget_ResizeRowToContents(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "resizeRowToContents", Q_ARG(int, row));
}

void QTableWidget_ResizeRowToContentsDefault(void* ptr, int row)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::resizeRowToContents(row);
}

void QTableWidget_ResizeRowsToContents(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "resizeRowsToContents");
}

void QTableWidget_ResizeRowsToContentsDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::resizeRowsToContents();
}

void QTableWidget_RowCountChanged(void* ptr, int oldCount, int newCount)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "rowCountChanged", Q_ARG(int, oldCount), Q_ARG(int, newCount));
}

void QTableWidget_RowCountChangedDefault(void* ptr, int oldCount, int newCount)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::rowCountChanged(oldCount, newCount);
}

void QTableWidget_RowMoved(void* ptr, int row, int oldIndex, int newIndex)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "rowMoved", Q_ARG(int, row), Q_ARG(int, oldIndex), Q_ARG(int, newIndex));
}

void QTableWidget_RowMovedDefault(void* ptr, int row, int oldIndex, int newIndex)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::rowMoved(row, oldIndex, newIndex);
}

void QTableWidget_RowResized(void* ptr, int row, int oldHeight, int newHeight)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "rowResized", Q_ARG(int, row), Q_ARG(int, oldHeight), Q_ARG(int, newHeight));
}

void QTableWidget_RowResizedDefault(void* ptr, int row, int oldHeight, int newHeight)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::rowResized(row, oldHeight, newHeight);
}

void QTableWidget_SelectColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "selectColumn", Q_ARG(int, column));
}

void QTableWidget_SelectColumnDefault(void* ptr, int column)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::selectColumn(column);
}

void QTableWidget_SelectRow(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "selectRow", Q_ARG(int, row));
}

void QTableWidget_SelectRowDefault(void* ptr, int row)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::selectRow(row);
}

void QTableWidget_SelectionChanged(void* ptr, void* selected, void* deselected)
{
	static_cast<QTableWidget*>(ptr)->selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

void QTableWidget_SelectionChangedDefault(void* ptr, void* selected, void* deselected)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

void QTableWidget_SetModel(void* ptr, void* model)
{
	static_cast<QTableWidget*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}

void QTableWidget_SetModelDefault(void* ptr, void* model)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setModel(static_cast<QAbstractItemModel*>(model));
}

void QTableWidget_SetRootIndex(void* ptr, void* index)
{
	static_cast<QTableWidget*>(ptr)->setRootIndex(*static_cast<QModelIndex*>(index));
}

void QTableWidget_SetRootIndexDefault(void* ptr, void* index)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setRootIndex(*static_cast<QModelIndex*>(index));
}

void QTableWidget_SetSelectionModel(void* ptr, void* selectionModel)
{
	static_cast<QTableWidget*>(ptr)->setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

void QTableWidget_SetSelectionModelDefault(void* ptr, void* selectionModel)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

void QTableWidget_ShowColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "showColumn", Q_ARG(int, column));
}

void QTableWidget_ShowColumnDefault(void* ptr, int column)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::showColumn(column);
}

void QTableWidget_ShowRow(void* ptr, int row)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "showRow", Q_ARG(int, row));
}

void QTableWidget_ShowRowDefault(void* ptr, int row)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::showRow(row);
}

int QTableWidget_SizeHintForColumn(void* ptr, int column)
{
	return static_cast<QTableWidget*>(ptr)->sizeHintForColumn(column);
}

int QTableWidget_SizeHintForColumnDefault(void* ptr, int column)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::sizeHintForColumn(column);
}

int QTableWidget_SizeHintForRow(void* ptr, int row)
{
	return static_cast<QTableWidget*>(ptr)->sizeHintForRow(row);
}

int QTableWidget_SizeHintForRowDefault(void* ptr, int row)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::sizeHintForRow(row);
}

void QTableWidget_UpdateGeometries(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->updateGeometries();
}

void QTableWidget_UpdateGeometriesDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::updateGeometries();
}

int QTableWidget_VerticalOffset(void* ptr)
{
	return static_cast<QTableWidget*>(ptr)->verticalOffset();
}

int QTableWidget_VerticalOffsetDefault(void* ptr)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::verticalOffset();
}

void* QTableWidget_ViewOptions(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QTableWidget*>(ptr)->viewOptions());
}

void* QTableWidget_ViewOptionsDefault(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QTableWidget*>(ptr)->QTableWidget::viewOptions());
}

void* QTableWidget_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableWidget*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTableWidget_ViewportSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableWidget*>(ptr)->QTableWidget::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTableWidget_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QTableWidget_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

char QTableWidget_ViewportEvent(void* ptr, void* event)
{
	return static_cast<QTableWidget*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}

char QTableWidget_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::viewportEvent(static_cast<QEvent*>(event));
}

void QTableWidget_ClearSelection(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "clearSelection");
}

void QTableWidget_ClearSelectionDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::clearSelection();
}

void QTableWidget_CloseEditor(void* ptr, void* editor, long long hint)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "closeEditor", Q_ARG(QWidget*, static_cast<QWidget*>(editor)), Q_ARG(QAbstractItemDelegate::EndEditHint, static_cast<QAbstractItemDelegate::EndEditHint>(hint)));
}

void QTableWidget_CloseEditorDefault(void* ptr, void* editor, long long hint)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
}

void QTableWidget_CommitData(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "commitData", Q_ARG(QWidget*, static_cast<QWidget*>(editor)));
}

void QTableWidget_CommitDataDefault(void* ptr, void* editor)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::commitData(static_cast<QWidget*>(editor));
}

void QTableWidget_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTableWidget_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTableWidget_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QTableWidget_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QTableWidget_Edit(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "edit", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTableWidget_EditDefault(void* ptr, void* index)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::edit(*static_cast<QModelIndex*>(index));
}

char QTableWidget_Edit2(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QTableWidget*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

char QTableWidget_Edit2Default(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

void QTableWidget_EditorDestroyed(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "editorDestroyed", Q_ARG(QObject*, static_cast<QObject*>(editor)));
}

void QTableWidget_EditorDestroyedDefault(void* ptr, void* editor)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::editorDestroyed(static_cast<QObject*>(editor));
}

void QTableWidget_FocusInEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QTableWidget_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QTableWidget_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QTableWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QTableWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::focusNextPrevChild(next != 0);
}

void QTableWidget_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTableWidget_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTableWidget_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QTableWidget_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QTableWidget_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QTableWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QTableWidget_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QTableWidget*>(ptr)->QTableWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QTableWidget_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QTableWidget_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QTableWidget_KeyboardSearch(void* ptr, char* search)
{
	static_cast<QTableWidget*>(ptr)->keyboardSearch(QString(search));
}

void QTableWidget_KeyboardSearchDefault(void* ptr, char* search)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::keyboardSearch(QString(search));
}

void QTableWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QTableWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QTableWidget_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTableWidget_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTableWidget_MousePressEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTableWidget_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTableWidget_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QTableWidget_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QTableWidget_Reset(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "reset");
}

void QTableWidget_ResetDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::reset();
}

void QTableWidget_ResizeEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QTableWidget_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QTableWidget_RowsAboutToBeRemoved(void* ptr, void* parent, int start, int end)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "rowsAboutToBeRemoved", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
}

void QTableWidget_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
}

void QTableWidget_RowsInserted(void* ptr, void* parent, int start, int end)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "rowsInserted", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
}

void QTableWidget_RowsInsertedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
}

void QTableWidget_ScrollTo(void* ptr, void* index, long long hint)
{
	static_cast<QTableWidget*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QTableWidget_ScrollToDefault(void* ptr, void* index, long long hint)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QTableWidget_ScrollToBottom(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "scrollToBottom");
}

void QTableWidget_ScrollToBottomDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::scrollToBottom();
}

void QTableWidget_ScrollToTop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "scrollToTop");
}

void QTableWidget_ScrollToTopDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::scrollToTop();
}

void QTableWidget_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "selectAll");
}

void QTableWidget_SelectAllDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::selectAll();
}

long long QTableWidget_SelectionCommand(void* ptr, void* index, void* event)
{
	return static_cast<QTableWidget*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

long long QTableWidget_SelectionCommandDefault(void* ptr, void* index, void* event)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

void QTableWidget_SetCurrentIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setCurrentIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTableWidget_SetCurrentIndexDefault(void* ptr, void* index)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setCurrentIndex(*static_cast<QModelIndex*>(index));
}

void QTableWidget_StartDrag(void* ptr, long long supportedActions)
{
	static_cast<QTableWidget*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QTableWidget_StartDragDefault(void* ptr, long long supportedActions)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QTableWidget_Update(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "update", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTableWidget_UpdateDefault(void* ptr, void* index)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::update(*static_cast<QModelIndex*>(index));
}

void* QTableWidget_VisualRect(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QTableWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QTableWidget_VisualRectDefault(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QTableWidget*>(ptr)->QTableWidget::visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QTableWidget_VisualRegionForSelection(void* ptr, void* selection)
{
	return new QRegion(static_cast<QTableWidget*>(ptr)->visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void* QTableWidget_VisualRegionForSelectionDefault(void* ptr, void* selection)
{
	return new QRegion(static_cast<QTableWidget*>(ptr)->QTableWidget::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void QTableWidget_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QTableWidget*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QTableWidget_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void* QTableWidget_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableWidget*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTableWidget_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableWidget*>(ptr)->QTableWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTableWidget_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QTableWidget*>(ptr)->scrollContentsBy(dx, dy);
}

void QTableWidget_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::scrollContentsBy(dx, dy);
}

void QTableWidget_SetupViewport(void* ptr, void* viewport)
{
	static_cast<QTableWidget*>(ptr)->setupViewport(static_cast<QWidget*>(viewport));
}

void QTableWidget_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setupViewport(static_cast<QWidget*>(viewport));
}

void* QTableWidget_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableWidget*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTableWidget_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableWidget*>(ptr)->QTableWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTableWidget_WheelEvent(void* ptr, void* e)
{
	static_cast<QTableWidget*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QTableWidget_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QTableWidget_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QTableWidget*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QTableWidget_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::changeEvent(static_cast<QEvent*>(ev));
}

void QTableWidget_ActionEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QTableWidget_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::actionEvent(static_cast<QActionEvent*>(event));
}

void QTableWidget_EnterEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QTableWidget_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::enterEvent(static_cast<QEvent*>(event));
}

void QTableWidget_HideEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QTableWidget_HideEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::hideEvent(static_cast<QHideEvent*>(event));
}

void QTableWidget_LeaveEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QTableWidget_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::leaveEvent(static_cast<QEvent*>(event));
}

void QTableWidget_MoveEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QTableWidget_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::moveEvent(static_cast<QMoveEvent*>(event));
}

void QTableWidget_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QTableWidget_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setEnabled(vbo != 0);
}

void QTableWidget_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QTableWidget_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setStyleSheet(QString(styleSheet));
}

void QTableWidget_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QTableWidget_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setVisible(visible != 0);
}

void QTableWidget_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QTableWidget_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setWindowModified(vbo != 0);
}

void QTableWidget_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QTableWidget_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setWindowTitle(QString(vqs));
}

void QTableWidget_ShowEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QTableWidget_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::showEvent(static_cast<QShowEvent*>(event));
}

char QTableWidget_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QTableWidget_CloseDefault(void* ptr)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::close();
}

void QTableWidget_CloseEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QTableWidget_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::closeEvent(static_cast<QCloseEvent*>(event));
}

char QTableWidget_HasHeightForWidth(void* ptr)
{
	return static_cast<QTableWidget*>(ptr)->hasHeightForWidth();
}

char QTableWidget_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::hasHeightForWidth();
}

int QTableWidget_HeightForWidth(void* ptr, int w)
{
	return static_cast<QTableWidget*>(ptr)->heightForWidth(w);
}

int QTableWidget_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::heightForWidth(w);
}

void QTableWidget_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "hide");
}

void QTableWidget_HideDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::hide();
}

void QTableWidget_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QTableWidget_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QTableWidget_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "lower");
}

void QTableWidget_LowerDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::lower();
}

char QTableWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTableWidget*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QTableWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QTableWidget_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "raise");
}

void QTableWidget_RaiseDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::raise();
}

void QTableWidget_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "repaint");
}

void QTableWidget_RepaintDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::repaint();
}

void QTableWidget_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QTableWidget_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setDisabled(disable != 0);
}

void QTableWidget_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setFocus");
}

void QTableWidget_SetFocus2Default(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setFocus();
}

void QTableWidget_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QTableWidget_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::setHidden(hidden != 0);
}

void QTableWidget_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "show");
}

void QTableWidget_ShowDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::show();
}

void QTableWidget_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "showFullScreen");
}

void QTableWidget_ShowFullScreenDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::showFullScreen();
}

void QTableWidget_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "showMaximized");
}

void QTableWidget_ShowMaximizedDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::showMaximized();
}

void QTableWidget_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "showMinimized");
}

void QTableWidget_ShowMinimizedDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::showMinimized();
}

void QTableWidget_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "showNormal");
}

void QTableWidget_ShowNormalDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::showNormal();
}

void QTableWidget_TabletEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTableWidget_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTableWidget_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "updateMicroFocus");
}

void QTableWidget_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::updateMicroFocus();
}

void QTableWidget_ChildEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QTableWidget_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::childEvent(static_cast<QChildEvent*>(event));
}

void QTableWidget_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QTableWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTableWidget_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTableWidget_CustomEvent(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QTableWidget_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::customEvent(static_cast<QEvent*>(event));
}

void QTableWidget_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "deleteLater");
}

void QTableWidget_DeleteLaterDefault(void* ptr)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::deleteLater();
}

void QTableWidget_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QTableWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTableWidget_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTableWidget*>(ptr)->QTableWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QTableWidget_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QTableWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QTableWidget_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QTableWidget*>(ptr)->QTableWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QTableWidget_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTableWidget*>(ptr)->metaObject());
}

void* QTableWidget_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTableWidget*>(ptr)->QTableWidget::metaObject());
}

class MyQTableWidgetItem: public QTableWidgetItem
{
public:
	MyQTableWidgetItem(const QIcon &icon, const QString &text, int type) : QTableWidgetItem(icon, text, type) {};
	MyQTableWidgetItem(const QString &text, int type) : QTableWidgetItem(text, type) {};
	MyQTableWidgetItem(const QTableWidgetItem &other) : QTableWidgetItem(other) {};
	MyQTableWidgetItem(int type) : QTableWidgetItem(type) {};
	QTableWidgetItem * clone() const { return static_cast<QTableWidgetItem*>(callbackQTableWidgetItem_Clone(const_cast<MyQTableWidgetItem*>(this))); };
	QVariant data(int role) const { return *static_cast<QVariant*>(callbackQTableWidgetItem_Data(const_cast<MyQTableWidgetItem*>(this), role)); };
	void setData(int role, const QVariant & value) { callbackQTableWidgetItem_SetData(this, role, const_cast<QVariant*>(&value)); };
	 ~MyQTableWidgetItem() { callbackQTableWidgetItem_DestroyQTableWidgetItem(this); };
};

void QTableWidgetItem_SetFlags(void* ptr, long long flags)
{
	static_cast<QTableWidgetItem*>(ptr)->setFlags(static_cast<Qt::ItemFlag>(flags));
}

void* QTableWidgetItem_NewQTableWidgetItem3(void* icon, char* text, int ty)
{
	return new MyQTableWidgetItem(*static_cast<QIcon*>(icon), QString(text), ty);
}

void* QTableWidgetItem_NewQTableWidgetItem2(char* text, int ty)
{
	return new MyQTableWidgetItem(QString(text), ty);
}

void* QTableWidgetItem_NewQTableWidgetItem4(void* other)
{
	return new MyQTableWidgetItem(*static_cast<QTableWidgetItem*>(other));
}

void* QTableWidgetItem_NewQTableWidgetItem(int ty)
{
	return new MyQTableWidgetItem(ty);
}

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();
}

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_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, char* statusTip)
{
	static_cast<QTableWidgetItem*>(ptr)->setStatusTip(QString(statusTip));
}

void QTableWidgetItem_SetText(void* ptr, char* text)
{
	static_cast<QTableWidgetItem*>(ptr)->setText(QString(text));
}

void QTableWidgetItem_SetTextAlignment(void* ptr, int alignment)
{
	static_cast<QTableWidgetItem*>(ptr)->setTextAlignment(alignment);
}

void QTableWidgetItem_SetToolTip(void* ptr, char* toolTip)
{
	static_cast<QTableWidgetItem*>(ptr)->setToolTip(QString(toolTip));
}

void QTableWidgetItem_SetWhatsThis(void* ptr, char* whatsThis)
{
	static_cast<QTableWidgetItem*>(ptr)->setWhatsThis(QString(whatsThis));
}

void* QTableWidgetItem_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTableWidgetItem*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

char* QTableWidgetItem_StatusTip(void* ptr)
{
	return const_cast<char*>(static_cast<QTableWidgetItem*>(ptr)->statusTip().toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QTableWidgetItem_TableWidget(void* ptr)
{
	return static_cast<QTableWidgetItem*>(ptr)->tableWidget();
}

char* QTableWidgetItem_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QTableWidgetItem*>(ptr)->text().toUtf8().prepend("WHITESPACE").constData()+10);
}

int QTableWidgetItem_TextAlignment(void* ptr)
{
	return static_cast<QTableWidgetItem*>(ptr)->textAlignment();
}

char* QTableWidgetItem_ToolTip(void* ptr)
{
	return const_cast<char*>(static_cast<QTableWidgetItem*>(ptr)->toolTip().toUtf8().prepend("WHITESPACE").constData()+10);
}

int QTableWidgetItem_Type(void* ptr)
{
	return static_cast<QTableWidgetItem*>(ptr)->type();
}

char* QTableWidgetItem_WhatsThis(void* ptr)
{
	return const_cast<char*>(static_cast<QTableWidgetItem*>(ptr)->whatsThis().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QTableWidgetItem_DestroyQTableWidgetItem(void* ptr)
{
	static_cast<QTableWidgetItem*>(ptr)->~QTableWidgetItem();
}

void QTableWidgetItem_DestroyQTableWidgetItemDefault(void* ptr)
{

}

void* QTableWidgetSelectionRange_NewQTableWidgetSelectionRange()
{
	return new QTableWidgetSelectionRange();
}

void* QTableWidgetSelectionRange_NewQTableWidgetSelectionRange3(void* other)
{
	return new QTableWidgetSelectionRange(*static_cast<QTableWidgetSelectionRange*>(other));
}

void* QTableWidgetSelectionRange_NewQTableWidgetSelectionRange2(int top, int left, int bottom, int right)
{
	return new QTableWidgetSelectionRange(top, left, bottom, right);
}

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();
}

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_TimerEvent(void* ptr, void* event)
{
	static_cast<QTapAndHoldGesture*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QTapAndHoldGesture_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::timerEvent(static_cast<QTimerEvent*>(event));
}

void QTapAndHoldGesture_ChildEvent(void* ptr, void* event)
{
	static_cast<QTapAndHoldGesture*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QTapAndHoldGesture_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::childEvent(static_cast<QChildEvent*>(event));
}

void QTapAndHoldGesture_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QTapAndHoldGesture*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTapAndHoldGesture_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTapAndHoldGesture_CustomEvent(void* ptr, void* event)
{
	static_cast<QTapAndHoldGesture*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QTapAndHoldGesture_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::customEvent(static_cast<QEvent*>(event));
}

void QTapAndHoldGesture_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTapAndHoldGesture*>(ptr), "deleteLater");
}

void QTapAndHoldGesture_DeleteLaterDefault(void* ptr)
{
	static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::deleteLater();
}

void QTapAndHoldGesture_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QTapAndHoldGesture*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTapAndHoldGesture_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QTapAndHoldGesture_Event(void* ptr, void* e)
{
	return static_cast<QTapAndHoldGesture*>(ptr)->event(static_cast<QEvent*>(e));
}

char QTapAndHoldGesture_EventDefault(void* ptr, void* e)
{
	return static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::event(static_cast<QEvent*>(e));
}

char QTapAndHoldGesture_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QTapAndHoldGesture*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QTapAndHoldGesture_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QTapAndHoldGesture_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTapAndHoldGesture*>(ptr)->metaObject());
}

void* QTapAndHoldGesture_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::metaObject());
}

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_TimerEvent(void* ptr, void* event)
{
	static_cast<QTapGesture*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QTapGesture_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QTapGesture*>(ptr)->QTapGesture::timerEvent(static_cast<QTimerEvent*>(event));
}

void QTapGesture_ChildEvent(void* ptr, void* event)
{
	static_cast<QTapGesture*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QTapGesture_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QTapGesture*>(ptr)->QTapGesture::childEvent(static_cast<QChildEvent*>(event));
}

void QTapGesture_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QTapGesture*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTapGesture_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTapGesture*>(ptr)->QTapGesture::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTapGesture_CustomEvent(void* ptr, void* event)
{
	static_cast<QTapGesture*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QTapGesture_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QTapGesture*>(ptr)->QTapGesture::customEvent(static_cast<QEvent*>(event));
}

void QTapGesture_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTapGesture*>(ptr), "deleteLater");
}

void QTapGesture_DeleteLaterDefault(void* ptr)
{
	static_cast<QTapGesture*>(ptr)->QTapGesture::deleteLater();
}

void QTapGesture_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QTapGesture*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTapGesture_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTapGesture*>(ptr)->QTapGesture::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QTapGesture_Event(void* ptr, void* e)
{
	return static_cast<QTapGesture*>(ptr)->event(static_cast<QEvent*>(e));
}

char QTapGesture_EventDefault(void* ptr, void* e)
{
	return static_cast<QTapGesture*>(ptr)->QTapGesture::event(static_cast<QEvent*>(e));
}

char QTapGesture_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QTapGesture*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QTapGesture_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QTapGesture*>(ptr)->QTapGesture::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QTapGesture_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTapGesture*>(ptr)->metaObject());
}

void* QTapGesture_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTapGesture*>(ptr)->QTapGesture::metaObject());
}

class MyQTextBrowser: public QTextBrowser
{
public:
	MyQTextBrowser(QWidget *parent) : QTextBrowser(parent) {};
	void setSource(const QUrl & name) { callbackQTextBrowser_SetSource(this, const_cast<QUrl*>(&name)); };
	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 callbackQTextBrowser_Event(this, e) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQTextBrowser_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * ev) { callbackQTextBrowser_FocusOutEvent(this, ev); };
	void forward() { callbackQTextBrowser_Forward(this); };
	void Signal_ForwardAvailable(bool available) { callbackQTextBrowser_ForwardAvailable(this, available); };
	void Signal_Highlighted2(const QString & link) { callbackQTextBrowser_Highlighted2(this, const_cast<char*>(link.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void Signal_Highlighted(const QUrl & link) { callbackQTextBrowser_Highlighted(this, const_cast<QUrl*>(&link)); };
	void Signal_HistoryChanged() { callbackQTextBrowser_HistoryChanged(this); };
	void home() { callbackQTextBrowser_Home(this); };
	void keyPressEvent(QKeyEvent * ev) { callbackQTextBrowser_KeyPressEvent(this, ev); };
	QVariant loadResource(int ty, const QUrl & name) { return *static_cast<QVariant*>(callbackQTextBrowser_LoadResource(this, ty, const_cast<QUrl*>(&name))); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQTextBrowser_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQTextBrowser_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQTextBrowser_MouseReleaseEvent(this, e); };
	void paintEvent(QPaintEvent * e) { callbackQTextBrowser_PaintEvent(this, e); };
	void reload() { callbackQTextBrowser_Reload(this); };
	void Signal_SourceChanged(const QUrl & src) { callbackQTextBrowser_SourceChanged(this, const_cast<QUrl*>(&src)); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQTextBrowser_ContextMenuEvent(this, event); };
	void redo() { callbackQTextBrowser_Redo(this); };
	void setFontWeight(int weight) { callbackQTextBrowser_SetFontWeight(this, weight); };
	void setHtml(const QString & text) { callbackQTextBrowser_SetHtml(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void zoomIn(int ran) { callbackQTextBrowser_ZoomIn(this, ran); };
	void zoomOut(int ran) { callbackQTextBrowser_ZoomOut(this, ran); };
	void append(const QString & text) { callbackQTextBrowser_Append(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool canInsertFromMimeData(const QMimeData * source) const { return callbackQTextBrowser_CanInsertFromMimeData(const_cast<MyQTextBrowser*>(this), const_cast<QMimeData*>(source)) != 0; };
	void changeEvent(QEvent * e) { callbackQTextBrowser_ChangeEvent(this, e); };
	void clear() { callbackQTextBrowser_Clear(this); };
	void copy() { callbackQTextBrowser_Copy(this); };
	QMimeData * createMimeDataFromSelection() const { return static_cast<QMimeData*>(callbackQTextBrowser_CreateMimeDataFromSelection(const_cast<MyQTextBrowser*>(this))); };
	void cut() { callbackQTextBrowser_Cut(this); };
	void dragEnterEvent(QDragEnterEvent * e) { callbackQTextBrowser_DragEnterEvent(this, e); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQTextBrowser_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQTextBrowser_DragMoveEvent(this, e); };
	void dropEvent(QDropEvent * e) { callbackQTextBrowser_DropEvent(this, e); };
	void focusInEvent(QFocusEvent * e) { callbackQTextBrowser_FocusInEvent(this, e); };
	void inputMethodEvent(QInputMethodEvent * e) { callbackQTextBrowser_InputMethodEvent(this, e); };
	QVariant inputMethodQuery(Qt::InputMethodQuery property) const { return *static_cast<QVariant*>(callbackQTextBrowser_InputMethodQuery(const_cast<MyQTextBrowser*>(this), property)); };
	void insertFromMimeData(const QMimeData * source) { callbackQTextBrowser_InsertFromMimeData(this, const_cast<QMimeData*>(source)); };
	void insertHtml(const QString & text) { callbackQTextBrowser_InsertHtml(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void insertPlainText(const QString & text) { callbackQTextBrowser_InsertPlainText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQTextBrowser_KeyReleaseEvent(this, e); };
	void mouseDoubleClickEvent(QMouseEvent * e) { callbackQTextBrowser_MouseDoubleClickEvent(this, e); };
	void paste() { callbackQTextBrowser_Paste(this); };
	void resizeEvent(QResizeEvent * e) { callbackQTextBrowser_ResizeEvent(this, e); };
	void scrollContentsBy(int dx, int dy) { callbackQTextBrowser_ScrollContentsBy(this, dx, dy); };
	void scrollToAnchor(const QString & name) { callbackQTextBrowser_ScrollToAnchor(this, const_cast<char*>(name.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void selectAll() { callbackQTextBrowser_SelectAll(this); };
	void setAlignment(Qt::Alignment a) { callbackQTextBrowser_SetAlignment(this, a); };
	void setCurrentFont(const QFont & f) { callbackQTextBrowser_SetCurrentFont(this, const_cast<QFont*>(&f)); };
	void setFontFamily(const QString & fontFamily) { callbackQTextBrowser_SetFontFamily(this, const_cast<char*>(fontFamily.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setFontItalic(bool italic) { callbackQTextBrowser_SetFontItalic(this, italic); };
	void setFontPointSize(qreal s) { callbackQTextBrowser_SetFontPointSize(this, s); };
	void setFontUnderline(bool underline) { callbackQTextBrowser_SetFontUnderline(this, underline); };
	void setPlainText(const QString & text) { callbackQTextBrowser_SetPlainText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setText(const QString & text) { callbackQTextBrowser_SetText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setTextBackgroundColor(const QColor & c) { callbackQTextBrowser_SetTextBackgroundColor(this, const_cast<QColor*>(&c)); };
	void setTextColor(const QColor & c) { callbackQTextBrowser_SetTextColor(this, const_cast<QColor*>(&c)); };
	void showEvent(QShowEvent * vqs) { callbackQTextBrowser_ShowEvent(this, vqs); };
	void undo() { callbackQTextBrowser_Undo(this); };
	void wheelEvent(QWheelEvent * e) { callbackQTextBrowser_WheelEvent(this, e); };
	bool viewportEvent(QEvent * event) { return callbackQTextBrowser_ViewportEvent(this, event) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTextBrowser_MinimumSizeHint(const_cast<MyQTextBrowser*>(this))); };
	void setupViewport(QWidget * viewport) { callbackQTextBrowser_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQTextBrowser_SizeHint(const_cast<MyQTextBrowser*>(this))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQTextBrowser_ViewportSizeHint(const_cast<MyQTextBrowser*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQTextBrowser_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQTextBrowser_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQTextBrowser_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQTextBrowser_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQTextBrowser_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQTextBrowser_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQTextBrowser_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQTextBrowser_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQTextBrowser_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQTextBrowser_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQTextBrowser_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQTextBrowser_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQTextBrowser_HasHeightForWidth(const_cast<MyQTextBrowser*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQTextBrowser_HeightForWidth(const_cast<MyQTextBrowser*>(this), w); };
	void hide() { callbackQTextBrowser_Hide(this); };
	void lower() { callbackQTextBrowser_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTextBrowser_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQTextBrowser_Raise(this); };
	void repaint() { callbackQTextBrowser_Repaint(this); };
	void setDisabled(bool disable) { callbackQTextBrowser_SetDisabled(this, disable); };
	void setFocus() { callbackQTextBrowser_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQTextBrowser_SetHidden(this, hidden); };
	void show() { callbackQTextBrowser_Show(this); };
	void showFullScreen() { callbackQTextBrowser_ShowFullScreen(this); };
	void showMaximized() { callbackQTextBrowser_ShowMaximized(this); };
	void showMinimized() { callbackQTextBrowser_ShowMinimized(this); };
	void showNormal() { callbackQTextBrowser_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQTextBrowser_TabletEvent(this, event); };
	void update() { callbackQTextBrowser_Update(this); };
	void updateMicroFocus() { callbackQTextBrowser_UpdateMicroFocus(this); };
	void timerEvent(QTimerEvent * event) { callbackQTextBrowser_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQTextBrowser_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTextBrowser_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTextBrowser_CustomEvent(this, event); };
	void deleteLater() { callbackQTextBrowser_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTextBrowser_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextBrowser_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextBrowser_MetaObject(const_cast<MyQTextBrowser*>(this))); };
};

char QTextBrowser_OpenExternalLinks(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->openExternalLinks();
}

char QTextBrowser_OpenLinks(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->openLinks();
}

char* QTextBrowser_SearchPaths(void* ptr)
{
	return const_cast<char*>(static_cast<QTextBrowser*>(ptr)->searchPaths().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

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, char* paths)
{
	static_cast<QTextBrowser*>(ptr)->setSearchPaths(QString(paths).split("|", QString::SkipEmptyParts));
}

void QTextBrowser_SetSource(void* ptr, void* name)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setSource", Q_ARG(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_NewQTextBrowser(void* parent)
{
	return new MyQTextBrowser(static_cast<QWidget*>(parent));
}

void QTextBrowser_ConnectAnchorClicked(void* ptr)
{
	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));
}

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)
{
	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));
}

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();
}

char QTextBrowser_Event(void* ptr, void* e)
{
	return static_cast<QTextBrowser*>(ptr)->event(static_cast<QEvent*>(e));
}

char QTextBrowser_EventDefault(void* ptr, void* e)
{
	return static_cast<QTextBrowser*>(ptr)->QTextBrowser::event(static_cast<QEvent*>(e));
}

char QTextBrowser_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QTextBrowser*>(ptr)->focusNextPrevChild(next != 0);
}

char QTextBrowser_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QTextBrowser*>(ptr)->QTextBrowser::focusNextPrevChild(next != 0);
}

void QTextBrowser_FocusOutEvent(void* ptr, void* ev)
{
	static_cast<QTextBrowser*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(ev));
}

void QTextBrowser_FocusOutEventDefault(void* ptr, void* ev)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::focusOutEvent(static_cast<QFocusEvent*>(ev));
}

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)
{
	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));
}

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_ConnectHighlighted2(void* ptr)
{
	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));
}

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, char* link)
{
	static_cast<QTextBrowser*>(ptr)->highlighted(QString(link));
}

void QTextBrowser_ConnectHighlighted(void* ptr)
{
	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));
}

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_ConnectHistoryChanged(void* ptr)
{
	QObject::connect(static_cast<QTextBrowser*>(ptr), static_cast<void (QTextBrowser::*)()>(&QTextBrowser::historyChanged), static_cast<MyQTextBrowser*>(ptr), static_cast<void (MyQTextBrowser::*)()>(&MyQTextBrowser::Signal_HistoryChanged));
}

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();
}

char* QTextBrowser_HistoryTitle(void* ptr, int i)
{
	return const_cast<char*>(static_cast<QTextBrowser*>(ptr)->historyTitle(i).toUtf8().prepend("WHITESPACE").constData()+10);
}

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();
}

void QTextBrowser_KeyPressEvent(void* ptr, void* ev)
{
	static_cast<QTextBrowser*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(ev));
}

void QTextBrowser_KeyPressEventDefault(void* ptr, void* ev)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::keyPressEvent(static_cast<QKeyEvent*>(ev));
}

void* QTextBrowser_LoadResource(void* ptr, int ty, void* name)
{
	return new QVariant(static_cast<QTextBrowser*>(ptr)->loadResource(ty, *static_cast<QUrl*>(name)));
}

void* QTextBrowser_LoadResourceDefault(void* ptr, int ty, void* name)
{
	return new QVariant(static_cast<QTextBrowser*>(ptr)->QTextBrowser::loadResource(ty, *static_cast<QUrl*>(name)));
}

void QTextBrowser_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QTextBrowser_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QTextBrowser_MousePressEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QTextBrowser_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QTextBrowser_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QTextBrowser_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QTextBrowser_PaintEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->paintEvent(static_cast<QPaintEvent*>(e));
}

void QTextBrowser_PaintEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::paintEvent(static_cast<QPaintEvent*>(e));
}

void QTextBrowser_Reload(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "reload");
}

void QTextBrowser_ReloadDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::reload();
}

void QTextBrowser_ConnectSourceChanged(void* ptr)
{
	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));
}

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));
}

void QTextBrowser_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QTextBrowser_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QTextBrowser_Redo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "redo");
}

void QTextBrowser_RedoDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::redo();
}

void QTextBrowser_SetFontWeight(void* ptr, int weight)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setFontWeight", Q_ARG(int, weight));
}

void QTextBrowser_SetFontWeightDefault(void* ptr, int weight)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setFontWeight(weight);
}

void QTextBrowser_SetHtml(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setHtml", Q_ARG(QString, QString(text)));
}

void QTextBrowser_SetHtmlDefault(void* ptr, char* text)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setHtml(QString(text));
}

void QTextBrowser_ZoomIn(void* ptr, int ran)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "zoomIn", Q_ARG(int, ran));
}

void QTextBrowser_ZoomInDefault(void* ptr, int ran)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::zoomIn(ran);
}

void QTextBrowser_ZoomOut(void* ptr, int ran)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "zoomOut", Q_ARG(int, ran));
}

void QTextBrowser_ZoomOutDefault(void* ptr, int ran)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::zoomOut(ran);
}

void QTextBrowser_Append(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "append", Q_ARG(QString, QString(text)));
}

void QTextBrowser_AppendDefault(void* ptr, char* text)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::append(QString(text));
}

char QTextBrowser_CanInsertFromMimeData(void* ptr, void* source)
{
	return static_cast<QTextBrowser*>(ptr)->canInsertFromMimeData(static_cast<QMimeData*>(source));
}

char QTextBrowser_CanInsertFromMimeDataDefault(void* ptr, void* source)
{
	return static_cast<QTextBrowser*>(ptr)->QTextBrowser::canInsertFromMimeData(static_cast<QMimeData*>(source));
}

void QTextBrowser_ChangeEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QTextBrowser_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::changeEvent(static_cast<QEvent*>(e));
}

void QTextBrowser_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "clear");
}

void QTextBrowser_ClearDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::clear();
}

void QTextBrowser_Copy(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "copy");
}

void QTextBrowser_CopyDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::copy();
}

void* QTextBrowser_CreateMimeDataFromSelection(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->createMimeDataFromSelection();
}

void* QTextBrowser_CreateMimeDataFromSelectionDefault(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->QTextBrowser::createMimeDataFromSelection();
}

void QTextBrowser_Cut(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "cut");
}

void QTextBrowser_CutDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::cut();
}

void QTextBrowser_DragEnterEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(e));
}

void QTextBrowser_DragEnterEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::dragEnterEvent(static_cast<QDragEnterEvent*>(e));
}

void QTextBrowser_DragLeaveEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QTextBrowser_DragLeaveEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QTextBrowser_DragMoveEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

void QTextBrowser_DragMoveEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

void QTextBrowser_DropEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->dropEvent(static_cast<QDropEvent*>(e));
}

void QTextBrowser_DropEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::dropEvent(static_cast<QDropEvent*>(e));
}

void QTextBrowser_FocusInEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(e));
}

void QTextBrowser_FocusInEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::focusInEvent(static_cast<QFocusEvent*>(e));
}

void QTextBrowser_InputMethodEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(e));
}

void QTextBrowser_InputMethodEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::inputMethodEvent(static_cast<QInputMethodEvent*>(e));
}

void* QTextBrowser_InputMethodQuery(void* ptr, long long property)
{
	return new QVariant(static_cast<QTextBrowser*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(property)));
}

void* QTextBrowser_InputMethodQueryDefault(void* ptr, long long property)
{
	return new QVariant(static_cast<QTextBrowser*>(ptr)->QTextBrowser::inputMethodQuery(static_cast<Qt::InputMethodQuery>(property)));
}

void QTextBrowser_InsertFromMimeData(void* ptr, void* source)
{
	static_cast<QTextBrowser*>(ptr)->insertFromMimeData(static_cast<QMimeData*>(source));
}

void QTextBrowser_InsertFromMimeDataDefault(void* ptr, void* source)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::insertFromMimeData(static_cast<QMimeData*>(source));
}

void QTextBrowser_InsertHtml(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "insertHtml", Q_ARG(QString, QString(text)));
}

void QTextBrowser_InsertHtmlDefault(void* ptr, char* text)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::insertHtml(QString(text));
}

void QTextBrowser_InsertPlainText(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "insertPlainText", Q_ARG(QString, QString(text)));
}

void QTextBrowser_InsertPlainTextDefault(void* ptr, char* text)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::insertPlainText(QString(text));
}

void QTextBrowser_KeyReleaseEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QTextBrowser_KeyReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QTextBrowser_MouseDoubleClickEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QTextBrowser_MouseDoubleClickEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QTextBrowser_Paste(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "paste");
}

void QTextBrowser_PasteDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::paste();
}

void QTextBrowser_ResizeEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(e));
}

void QTextBrowser_ResizeEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::resizeEvent(static_cast<QResizeEvent*>(e));
}

void QTextBrowser_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QTextBrowser*>(ptr)->scrollContentsBy(dx, dy);
}

void QTextBrowser_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::scrollContentsBy(dx, dy);
}

void QTextBrowser_ScrollToAnchor(void* ptr, char* name)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "scrollToAnchor", Q_ARG(QString, QString(name)));
}

void QTextBrowser_ScrollToAnchorDefault(void* ptr, char* name)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::scrollToAnchor(QString(name));
}

void QTextBrowser_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "selectAll");
}

void QTextBrowser_SelectAllDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::selectAll();
}

void QTextBrowser_SetAlignment(void* ptr, long long a)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setAlignment", Q_ARG(Qt::AlignmentFlag, static_cast<Qt::AlignmentFlag>(a)));
}

void QTextBrowser_SetAlignmentDefault(void* ptr, long long a)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setAlignment(static_cast<Qt::AlignmentFlag>(a));
}

void QTextBrowser_SetCurrentFont(void* ptr, void* f)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setCurrentFont", Q_ARG(QFont, *static_cast<QFont*>(f)));
}

void QTextBrowser_SetCurrentFontDefault(void* ptr, void* f)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setCurrentFont(*static_cast<QFont*>(f));
}

void QTextBrowser_SetFontFamily(void* ptr, char* fontFamily)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setFontFamily", Q_ARG(QString, QString(fontFamily)));
}

void QTextBrowser_SetFontFamilyDefault(void* ptr, char* fontFamily)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setFontFamily(QString(fontFamily));
}

void QTextBrowser_SetFontItalic(void* ptr, char italic)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setFontItalic", Q_ARG(bool, italic != 0));
}

void QTextBrowser_SetFontItalicDefault(void* ptr, char italic)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setFontItalic(italic != 0);
}

void QTextBrowser_SetFontPointSize(void* ptr, double s)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setFontPointSize", Q_ARG(qreal, s));
}

void QTextBrowser_SetFontPointSizeDefault(void* ptr, double s)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setFontPointSize(s);
}

void QTextBrowser_SetFontUnderline(void* ptr, char underline)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setFontUnderline", Q_ARG(bool, underline != 0));
}

void QTextBrowser_SetFontUnderlineDefault(void* ptr, char underline)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setFontUnderline(underline != 0);
}

void QTextBrowser_SetPlainText(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setPlainText", Q_ARG(QString, QString(text)));
}

void QTextBrowser_SetPlainTextDefault(void* ptr, char* text)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setPlainText(QString(text));
}

void QTextBrowser_SetText(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setText", Q_ARG(QString, QString(text)));
}

void QTextBrowser_SetTextDefault(void* ptr, char* text)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setText(QString(text));
}

void QTextBrowser_SetTextBackgroundColor(void* ptr, void* c)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setTextBackgroundColor", Q_ARG(QColor, *static_cast<QColor*>(c)));
}

void QTextBrowser_SetTextBackgroundColorDefault(void* ptr, void* c)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setTextBackgroundColor(*static_cast<QColor*>(c));
}

void QTextBrowser_SetTextColor(void* ptr, void* c)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setTextColor", Q_ARG(QColor, *static_cast<QColor*>(c)));
}

void QTextBrowser_SetTextColorDefault(void* ptr, void* c)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setTextColor(*static_cast<QColor*>(c));
}

void QTextBrowser_ShowEvent(void* ptr, void* vqs)
{
	static_cast<QTextBrowser*>(ptr)->showEvent(static_cast<QShowEvent*>(vqs));
}

void QTextBrowser_ShowEventDefault(void* ptr, void* vqs)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::showEvent(static_cast<QShowEvent*>(vqs));
}

void QTextBrowser_Undo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "undo");
}

void QTextBrowser_UndoDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::undo();
}

void QTextBrowser_WheelEvent(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QTextBrowser_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::wheelEvent(static_cast<QWheelEvent*>(e));
}

char QTextBrowser_ViewportEvent(void* ptr, void* event)
{
	return static_cast<QTextBrowser*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}

char QTextBrowser_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QTextBrowser*>(ptr)->QTextBrowser::viewportEvent(static_cast<QEvent*>(event));
}

void* QTextBrowser_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTextBrowser*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTextBrowser_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTextBrowser*>(ptr)->QTextBrowser::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTextBrowser_SetupViewport(void* ptr, void* viewport)
{
	static_cast<QTextBrowser*>(ptr)->setupViewport(static_cast<QWidget*>(viewport));
}

void QTextBrowser_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setupViewport(static_cast<QWidget*>(viewport));
}

void* QTextBrowser_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTextBrowser*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTextBrowser_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTextBrowser*>(ptr)->QTextBrowser::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTextBrowser_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTextBrowser*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTextBrowser_ViewportSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTextBrowser*>(ptr)->QTextBrowser::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTextBrowser_ActionEvent(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QTextBrowser_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::actionEvent(static_cast<QActionEvent*>(event));
}

void QTextBrowser_EnterEvent(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QTextBrowser_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::enterEvent(static_cast<QEvent*>(event));
}

void QTextBrowser_HideEvent(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QTextBrowser_HideEventDefault(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::hideEvent(static_cast<QHideEvent*>(event));
}

void QTextBrowser_LeaveEvent(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QTextBrowser_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::leaveEvent(static_cast<QEvent*>(event));
}

void QTextBrowser_MoveEvent(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QTextBrowser_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::moveEvent(static_cast<QMoveEvent*>(event));
}

void QTextBrowser_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QTextBrowser_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setEnabled(vbo != 0);
}

void QTextBrowser_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QTextBrowser_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setStyleSheet(QString(styleSheet));
}

void QTextBrowser_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QTextBrowser_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setVisible(visible != 0);
}

void QTextBrowser_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QTextBrowser_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setWindowModified(vbo != 0);
}

void QTextBrowser_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QTextBrowser_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setWindowTitle(QString(vqs));
}

char QTextBrowser_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QTextBrowser_CloseDefault(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->QTextBrowser::close();
}

void QTextBrowser_CloseEvent(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QTextBrowser_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::closeEvent(static_cast<QCloseEvent*>(event));
}

char QTextBrowser_HasHeightForWidth(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->hasHeightForWidth();
}

char QTextBrowser_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QTextBrowser*>(ptr)->QTextBrowser::hasHeightForWidth();
}

int QTextBrowser_HeightForWidth(void* ptr, int w)
{
	return static_cast<QTextBrowser*>(ptr)->heightForWidth(w);
}

int QTextBrowser_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QTextBrowser*>(ptr)->QTextBrowser::heightForWidth(w);
}

void QTextBrowser_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "hide");
}

void QTextBrowser_HideDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::hide();
}

void QTextBrowser_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "lower");
}

void QTextBrowser_LowerDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::lower();
}

char QTextBrowser_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTextBrowser*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QTextBrowser_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTextBrowser*>(ptr)->QTextBrowser::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QTextBrowser_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "raise");
}

void QTextBrowser_RaiseDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::raise();
}

void QTextBrowser_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "repaint");
}

void QTextBrowser_RepaintDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::repaint();
}

void QTextBrowser_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QTextBrowser_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setDisabled(disable != 0);
}

void QTextBrowser_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setFocus");
}

void QTextBrowser_SetFocus2Default(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setFocus();
}

void QTextBrowser_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QTextBrowser_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::setHidden(hidden != 0);
}

void QTextBrowser_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "show");
}

void QTextBrowser_ShowDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::show();
}

void QTextBrowser_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "showFullScreen");
}

void QTextBrowser_ShowFullScreenDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::showFullScreen();
}

void QTextBrowser_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "showMaximized");
}

void QTextBrowser_ShowMaximizedDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::showMaximized();
}

void QTextBrowser_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "showMinimized");
}

void QTextBrowser_ShowMinimizedDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::showMinimized();
}

void QTextBrowser_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "showNormal");
}

void QTextBrowser_ShowNormalDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::showNormal();
}

void QTextBrowser_TabletEvent(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTextBrowser_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTextBrowser_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "update");
}

void QTextBrowser_UpdateDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::update();
}

void QTextBrowser_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "updateMicroFocus");
}

void QTextBrowser_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::updateMicroFocus();
}

void QTextBrowser_TimerEvent(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QTextBrowser_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::timerEvent(static_cast<QTimerEvent*>(event));
}

void QTextBrowser_ChildEvent(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QTextBrowser_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::childEvent(static_cast<QChildEvent*>(event));
}

void QTextBrowser_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QTextBrowser*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTextBrowser_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTextBrowser_CustomEvent(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QTextBrowser_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::customEvent(static_cast<QEvent*>(event));
}

void QTextBrowser_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "deleteLater");
}

void QTextBrowser_DeleteLaterDefault(void* ptr)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::deleteLater();
}

void QTextBrowser_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QTextBrowser*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTextBrowser_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTextBrowser*>(ptr)->QTextBrowser::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QTextBrowser_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QTextBrowser*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QTextBrowser_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QTextBrowser*>(ptr)->QTextBrowser::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QTextBrowser_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTextBrowser*>(ptr)->metaObject());
}

void* QTextBrowser_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTextBrowser*>(ptr)->QTextBrowser::metaObject());
}

class MyQTextEdit: public QTextEdit
{
public:
	MyQTextEdit(QWidget *parent) : QTextEdit(parent) {};
	MyQTextEdit(const QString &text, QWidget *parent) : QTextEdit(text, parent) {};
	void contextMenuEvent(QContextMenuEvent * event) { callbackQTextEdit_ContextMenuEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQTextEdit_PaintEvent(this, event); };
	void redo() { callbackQTextEdit_Redo(this); };
	void setFontWeight(int weight) { callbackQTextEdit_SetFontWeight(this, weight); };
	void setHtml(const QString & text) { callbackQTextEdit_SetHtml(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void zoomIn(int ran) { callbackQTextEdit_ZoomIn(this, ran); };
	void zoomOut(int ran) { callbackQTextEdit_ZoomOut(this, ran); };
	void append(const QString & text) { callbackQTextEdit_Append(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool canInsertFromMimeData(const QMimeData * source) const { return callbackQTextEdit_CanInsertFromMimeData(const_cast<MyQTextEdit*>(this), const_cast<QMimeData*>(source)) != 0; };
	void changeEvent(QEvent * e) { callbackQTextEdit_ChangeEvent(this, e); };
	void clear() { callbackQTextEdit_Clear(this); };
	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<MyQTextEdit*>(this))); };
	void Signal_CurrentCharFormatChanged(const QTextCharFormat & f) { callbackQTextEdit_CurrentCharFormatChanged(this, const_cast<QTextCharFormat*>(&f)); };
	void Signal_CursorPositionChanged() { callbackQTextEdit_CursorPositionChanged(this); };
	void cut() { callbackQTextEdit_Cut(this); };
	void dragEnterEvent(QDragEnterEvent * e) { callbackQTextEdit_DragEnterEvent(this, e); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQTextEdit_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQTextEdit_DragMoveEvent(this, e); };
	void dropEvent(QDropEvent * e) { callbackQTextEdit_DropEvent(this, e); };
	void focusInEvent(QFocusEvent * e) { callbackQTextEdit_FocusInEvent(this, e); };
	bool focusNextPrevChild(bool next) { return callbackQTextEdit_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * e) { callbackQTextEdit_FocusOutEvent(this, e); };
	void inputMethodEvent(QInputMethodEvent * e) { callbackQTextEdit_InputMethodEvent(this, e); };
	QVariant inputMethodQuery(Qt::InputMethodQuery property) const { return *static_cast<QVariant*>(callbackQTextEdit_InputMethodQuery(const_cast<MyQTextEdit*>(this), property)); };
	void insertFromMimeData(const QMimeData * source) { callbackQTextEdit_InsertFromMimeData(this, const_cast<QMimeData*>(source)); };
	void insertHtml(const QString & text) { callbackQTextEdit_InsertHtml(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void insertPlainText(const QString & text) { callbackQTextEdit_InsertPlainText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void keyPressEvent(QKeyEvent * e) { callbackQTextEdit_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQTextEdit_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) { callbackQTextEdit_MouseDoubleClickEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQTextEdit_MouseMoveEvent(this, e); };
	void mousePressEvent(QMouseEvent * e) { callbackQTextEdit_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQTextEdit_MouseReleaseEvent(this, e); };
	void paste() { callbackQTextEdit_Paste(this); };
	void Signal_RedoAvailable(bool available) { callbackQTextEdit_RedoAvailable(this, available); };
	void resizeEvent(QResizeEvent * e) { callbackQTextEdit_ResizeEvent(this, e); };
	void scrollContentsBy(int dx, int dy) { callbackQTextEdit_ScrollContentsBy(this, dx, dy); };
	void scrollToAnchor(const QString & name) { callbackQTextEdit_ScrollToAnchor(this, const_cast<char*>(name.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void selectAll() { callbackQTextEdit_SelectAll(this); };
	void Signal_SelectionChanged() { callbackQTextEdit_SelectionChanged(this); };
	void setAlignment(Qt::Alignment a) { callbackQTextEdit_SetAlignment(this, a); };
	void setCurrentFont(const QFont & f) { callbackQTextEdit_SetCurrentFont(this, const_cast<QFont*>(&f)); };
	void setFontFamily(const QString & fontFamily) { callbackQTextEdit_SetFontFamily(this, const_cast<char*>(fontFamily.toUtf8().prepend("WHITESPACE").constData()+10)); };
	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 setPlainText(const QString & text) { callbackQTextEdit_SetPlainText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setText(const QString & text) { callbackQTextEdit_SetText(this, const_cast<char*>(text.toUtf8().prepend("WHITESPACE").constData()+10)); };
	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) { callbackQTextEdit_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) { callbackQTextEdit_WheelEvent(this, e); };
	 ~MyQTextEdit() { callbackQTextEdit_DestroyQTextEdit(this); };
	bool viewportEvent(QEvent * event) { return callbackQTextEdit_ViewportEvent(this, event) != 0; };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTextEdit_MinimumSizeHint(const_cast<MyQTextEdit*>(this))); };
	void setupViewport(QWidget * viewport) { callbackQTextEdit_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQTextEdit_SizeHint(const_cast<MyQTextEdit*>(this))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQTextEdit_ViewportSizeHint(const_cast<MyQTextEdit*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQTextEdit_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQTextEdit_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQTextEdit_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQTextEdit_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQTextEdit_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQTextEdit_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQTextEdit_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQTextEdit_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQTextEdit_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQTextEdit_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQTextEdit_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQTextEdit_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQTextEdit_HasHeightForWidth(const_cast<MyQTextEdit*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQTextEdit_HeightForWidth(const_cast<MyQTextEdit*>(this), w); };
	void hide() { callbackQTextEdit_Hide(this); };
	void lower() { callbackQTextEdit_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTextEdit_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQTextEdit_Raise(this); };
	void repaint() { callbackQTextEdit_Repaint(this); };
	void setDisabled(bool disable) { callbackQTextEdit_SetDisabled(this, disable); };
	void setFocus() { callbackQTextEdit_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQTextEdit_SetHidden(this, hidden); };
	void show() { callbackQTextEdit_Show(this); };
	void showFullScreen() { callbackQTextEdit_ShowFullScreen(this); };
	void showMaximized() { callbackQTextEdit_ShowMaximized(this); };
	void showMinimized() { callbackQTextEdit_ShowMinimized(this); };
	void showNormal() { callbackQTextEdit_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQTextEdit_TabletEvent(this, event); };
	void update() { callbackQTextEdit_Update(this); };
	void updateMicroFocus() { callbackQTextEdit_UpdateMicroFocus(this); };
	void timerEvent(QTimerEvent * event) { callbackQTextEdit_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQTextEdit_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTextEdit_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTextEdit_CustomEvent(this, event); };
	void deleteLater() { callbackQTextEdit_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTextEdit_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextEdit_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextEdit_MetaObject(const_cast<MyQTextEdit*>(this))); };
};

char QTextEdit_AcceptRichText(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->acceptRichText();
}

long long QTextEdit_AutoFormatting(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->autoFormatting();
}

void QTextEdit_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QTextEdit_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

int QTextEdit_CursorWidth(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->cursorWidth();
}

void* QTextEdit_Document(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->document();
}

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_IsReadOnly(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->isReadOnly();
}

int QTextEdit_LineWrapColumnOrWidth(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->lineWrapColumnOrWidth();
}

long long QTextEdit_LineWrapMode(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->lineWrapMode();
}

char QTextEdit_OverwriteMode(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->overwriteMode();
}

void QTextEdit_PaintEvent(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QTextEdit_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::paintEvent(static_cast<QPaintEvent*>(event));
}

char* QTextEdit_PlaceholderText(void* ptr)
{
	return const_cast<char*>(static_cast<QTextEdit*>(ptr)->placeholderText().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QTextEdit_Redo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "redo");
}

void QTextEdit_SetAcceptRichText(void* ptr, char accept)
{
	static_cast<QTextEdit*>(ptr)->setAcceptRichText(accept != 0);
}

void QTextEdit_SetAutoFormatting(void* ptr, long long features)
{
	static_cast<QTextEdit*>(ptr)->setAutoFormatting(static_cast<QTextEdit::AutoFormattingFlag>(features));
}

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_SetFontWeight(void* ptr, int weight)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setFontWeight", Q_ARG(int, weight));
}

void QTextEdit_SetHtml(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setHtml", Q_ARG(QString, QString(text)));
}

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, char* placeholderText)
{
	static_cast<QTextEdit*>(ptr)->setPlaceholderText(QString(placeholderText));
}

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_SetTabStopWidth(void* ptr, int width)
{
	static_cast<QTextEdit*>(ptr)->setTabStopWidth(width);
}

void QTextEdit_SetTextInteractionFlags(void* ptr, long long flags)
{
	static_cast<QTextEdit*>(ptr)->setTextInteractionFlags(static_cast<Qt::TextInteractionFlag>(flags));
}

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();
}

int QTextEdit_TabStopWidth(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->tabStopWidth();
}

long long QTextEdit_TextInteractionFlags(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->textInteractionFlags();
}

char* QTextEdit_ToHtml(void* ptr)
{
	return const_cast<char*>(static_cast<QTextEdit*>(ptr)->toHtml().toUtf8().prepend("WHITESPACE").constData()+10);
}

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_ZoomOut(void* ptr, int ran)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "zoomOut", Q_ARG(int, ran));
}

void* QTextEdit_NewQTextEdit(void* parent)
{
	return new MyQTextEdit(static_cast<QWidget*>(parent));
}

void* QTextEdit_NewQTextEdit2(char* text, void* parent)
{
	return new MyQTextEdit(QString(text), static_cast<QWidget*>(parent));
}

long long QTextEdit_Alignment(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->alignment();
}

char* QTextEdit_AnchorAt(void* ptr, void* pos)
{
	return const_cast<char*>(static_cast<QTextEdit*>(ptr)->anchorAt(*static_cast<QPoint*>(pos)).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QTextEdit_Append(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "append", Q_ARG(QString, QString(text)));
}

char QTextEdit_CanInsertFromMimeData(void* ptr, void* source)
{
	return static_cast<QTextEdit*>(ptr)->canInsertFromMimeData(static_cast<QMimeData*>(source));
}

char QTextEdit_CanInsertFromMimeDataDefault(void* ptr, void* source)
{
	return static_cast<QTextEdit*>(ptr)->QTextEdit::canInsertFromMimeData(static_cast<QMimeData*>(source));
}

char QTextEdit_CanPaste(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->canPaste();
}

void QTextEdit_ChangeEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QTextEdit_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::changeEvent(static_cast<QEvent*>(e));
}

void QTextEdit_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "clear");
}

void QTextEdit_Copy(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "copy");
}

void QTextEdit_ConnectCopyAvailable(void* ptr)
{
	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));
}

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)
{
	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_ConnectCurrentCharFormatChanged(void* ptr)
{
	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));
}

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* f)
{
	static_cast<QTextEdit*>(ptr)->currentCharFormatChanged(*static_cast<QTextCharFormat*>(f));
}

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)
{
	QObject::connect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)()>(&QTextEdit::cursorPositionChanged), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)()>(&MyQTextEdit::Signal_CursorPositionChanged));
}

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_CursorRect2(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QTextEdit*>(ptr)->cursorRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

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_Cut(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "cut");
}

char* QTextEdit_DocumentTitle(void* ptr)
{
	return const_cast<char*>(static_cast<QTextEdit*>(ptr)->documentTitle().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QTextEdit_DragEnterEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(e));
}

void QTextEdit_DragEnterEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(e));
}

void QTextEdit_DragLeaveEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QTextEdit_DragLeaveEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QTextEdit_DragMoveEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

void QTextEdit_DragMoveEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

void QTextEdit_DropEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->dropEvent(static_cast<QDropEvent*>(e));
}

void QTextEdit_DropEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::dropEvent(static_cast<QDropEvent*>(e));
}

void QTextEdit_EnsureCursorVisible(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->ensureCursorVisible();
}

char QTextEdit_Find(void* ptr, char* exp, long long options)
{
	return static_cast<QTextEdit*>(ptr)->find(QString(exp), static_cast<QTextDocument::FindFlag>(options));
}

void QTextEdit_FocusInEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(e));
}

void QTextEdit_FocusInEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::focusInEvent(static_cast<QFocusEvent*>(e));
}

char QTextEdit_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QTextEdit*>(ptr)->focusNextPrevChild(next != 0);
}

char QTextEdit_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QTextEdit*>(ptr)->QTextEdit::focusNextPrevChild(next != 0);
}

void QTextEdit_FocusOutEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QTextEdit_FocusOutEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::focusOutEvent(static_cast<QFocusEvent*>(e));
}

char* QTextEdit_FontFamily(void* ptr)
{
	return const_cast<char*>(static_cast<QTextEdit*>(ptr)->fontFamily().toUtf8().prepend("WHITESPACE").constData()+10);
}

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_InputMethodEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(e));
}

void QTextEdit_InputMethodEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(e));
}

void* QTextEdit_InputMethodQuery(void* ptr, long long property)
{
	return new QVariant(static_cast<QTextEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(property)));
}

void* QTextEdit_InputMethodQueryDefault(void* ptr, long long property)
{
	return new QVariant(static_cast<QTextEdit*>(ptr)->QTextEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(property)));
}

void QTextEdit_InsertFromMimeData(void* ptr, void* source)
{
	static_cast<QTextEdit*>(ptr)->insertFromMimeData(static_cast<QMimeData*>(source));
}

void QTextEdit_InsertFromMimeDataDefault(void* ptr, void* source)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::insertFromMimeData(static_cast<QMimeData*>(source));
}

void QTextEdit_InsertHtml(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "insertHtml", Q_ARG(QString, QString(text)));
}

void QTextEdit_InsertPlainText(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "insertPlainText", Q_ARG(QString, QString(text)));
}

char QTextEdit_IsUndoRedoEnabled(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->isUndoRedoEnabled();
}

void QTextEdit_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QTextEdit_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QTextEdit_KeyReleaseEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QTextEdit_KeyReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

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)
{
	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_MouseDoubleClickEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QTextEdit_MouseDoubleClickEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(e));
}

void QTextEdit_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QTextEdit_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QTextEdit_MousePressEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QTextEdit_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QTextEdit_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QTextEdit_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

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));
}

void QTextEdit_Paste(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "paste");
}

void QTextEdit_Print(void* ptr, void* printer)
{
#ifndef Q_OS_IOS
	static_cast<QTextEdit*>(ptr)->print(static_cast<QPagedPaintDevice*>(printer));
#endif
}

void QTextEdit_ConnectRedoAvailable(void* ptr)
{
	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));
}

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_ResizeEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(e));
}

void QTextEdit_ResizeEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::resizeEvent(static_cast<QResizeEvent*>(e));
}

void QTextEdit_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QTextEdit*>(ptr)->scrollContentsBy(dx, dy);
}

void QTextEdit_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::scrollContentsBy(dx, dy);
}

void QTextEdit_ScrollToAnchor(void* ptr, char* name)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "scrollToAnchor", Q_ARG(QString, QString(name)));
}

void QTextEdit_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "selectAll");
}

void QTextEdit_ConnectSelectionChanged(void* ptr)
{
	QObject::connect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)()>(&QTextEdit::selectionChanged), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)()>(&MyQTextEdit::Signal_SelectionChanged));
}

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_SetAlignment(void* ptr, long long a)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setAlignment", Q_ARG(Qt::AlignmentFlag, static_cast<Qt::AlignmentFlag>(a)));
}

void QTextEdit_SetCurrentCharFormat(void* ptr, void* format)
{
	static_cast<QTextEdit*>(ptr)->setCurrentCharFormat(*static_cast<QTextCharFormat*>(format));
}

void QTextEdit_SetCurrentFont(void* ptr, void* f)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setCurrentFont", Q_ARG(QFont, *static_cast<QFont*>(f)));
}

void QTextEdit_SetDocumentTitle(void* ptr, char* title)
{
	static_cast<QTextEdit*>(ptr)->setDocumentTitle(QString(title));
}

void QTextEdit_SetFontFamily(void* ptr, char* fontFamily)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setFontFamily", Q_ARG(QString, QString(fontFamily)));
}

void QTextEdit_SetFontItalic(void* ptr, char italic)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setFontItalic", Q_ARG(bool, italic != 0));
}

void QTextEdit_SetFontPointSize(void* ptr, double s)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setFontPointSize", Q_ARG(qreal, s));
}

void QTextEdit_SetFontUnderline(void* ptr, char underline)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setFontUnderline", Q_ARG(bool, underline != 0));
}

void QTextEdit_SetPlainText(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setPlainText", Q_ARG(QString, QString(text)));
}

void QTextEdit_SetText(void* ptr, char* text)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setText", Q_ARG(QString, QString(text)));
}

void QTextEdit_SetTextBackgroundColor(void* ptr, void* c)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setTextBackgroundColor", Q_ARG(QColor, *static_cast<QColor*>(c)));
}

void QTextEdit_SetTextColor(void* ptr, void* c)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setTextColor", Q_ARG(QColor, *static_cast<QColor*>(c)));
}

void QTextEdit_SetTextCursor(void* ptr, void* cursor)
{
	static_cast<QTextEdit*>(ptr)->setTextCursor(*static_cast<QTextCursor*>(cursor));
}

void QTextEdit_SetUndoRedoEnabled(void* ptr, char enable)
{
	static_cast<QTextEdit*>(ptr)->setUndoRedoEnabled(enable != 0);
}

void QTextEdit_ShowEvent(void* ptr, void* vqs)
{
	static_cast<QTextEdit*>(ptr)->showEvent(static_cast<QShowEvent*>(vqs));
}

void QTextEdit_ShowEventDefault(void* ptr, void* vqs)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::showEvent(static_cast<QShowEvent*>(vqs));
}

void* QTextEdit_TextBackgroundColor(void* ptr)
{
	return new QColor(static_cast<QTextEdit*>(ptr)->textBackgroundColor());
}

void QTextEdit_ConnectTextChanged(void* ptr)
{
	QObject::connect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)()>(&QTextEdit::textChanged), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)()>(&MyQTextEdit::Signal_TextChanged));
}

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());
}

char* QTextEdit_ToPlainText(void* ptr)
{
	return const_cast<char*>(static_cast<QTextEdit*>(ptr)->toPlainText().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QTextEdit_Undo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "undo");
}

void QTextEdit_ConnectUndoAvailable(void* ptr)
{
	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));
}

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);
}

void QTextEdit_WheelEvent(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QTextEdit_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QTextEdit_DestroyQTextEdit(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->~QTextEdit();
}

void QTextEdit_DestroyQTextEditDefault(void* ptr)
{

}

char QTextEdit_ViewportEvent(void* ptr, void* event)
{
	return static_cast<QTextEdit*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}

char QTextEdit_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QTextEdit*>(ptr)->QTextEdit::viewportEvent(static_cast<QEvent*>(event));
}

void* QTextEdit_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTextEdit*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTextEdit_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTextEdit*>(ptr)->QTextEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTextEdit_SetupViewport(void* ptr, void* viewport)
{
	static_cast<QTextEdit*>(ptr)->setupViewport(static_cast<QWidget*>(viewport));
}

void QTextEdit_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::setupViewport(static_cast<QWidget*>(viewport));
}

void* QTextEdit_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTextEdit*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTextEdit_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTextEdit*>(ptr)->QTextEdit::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTextEdit_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTextEdit*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTextEdit_ViewportSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTextEdit*>(ptr)->QTextEdit::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTextEdit_ActionEvent(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QTextEdit_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::actionEvent(static_cast<QActionEvent*>(event));
}

void QTextEdit_EnterEvent(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QTextEdit_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::enterEvent(static_cast<QEvent*>(event));
}

void QTextEdit_HideEvent(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QTextEdit_HideEventDefault(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::hideEvent(static_cast<QHideEvent*>(event));
}

void QTextEdit_LeaveEvent(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QTextEdit_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::leaveEvent(static_cast<QEvent*>(event));
}

void QTextEdit_MoveEvent(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QTextEdit_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::moveEvent(static_cast<QMoveEvent*>(event));
}

void QTextEdit_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QTextEdit_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::setEnabled(vbo != 0);
}

void QTextEdit_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QTextEdit_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::setStyleSheet(QString(styleSheet));
}

void QTextEdit_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QTextEdit_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::setVisible(visible != 0);
}

void QTextEdit_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QTextEdit_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::setWindowModified(vbo != 0);
}

void QTextEdit_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QTextEdit_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::setWindowTitle(QString(vqs));
}

char QTextEdit_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QTextEdit_CloseDefault(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->QTextEdit::close();
}

void QTextEdit_CloseEvent(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QTextEdit_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::closeEvent(static_cast<QCloseEvent*>(event));
}

char QTextEdit_HasHeightForWidth(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->hasHeightForWidth();
}

char QTextEdit_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QTextEdit*>(ptr)->QTextEdit::hasHeightForWidth();
}

int QTextEdit_HeightForWidth(void* ptr, int w)
{
	return static_cast<QTextEdit*>(ptr)->heightForWidth(w);
}

int QTextEdit_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QTextEdit*>(ptr)->QTextEdit::heightForWidth(w);
}

void QTextEdit_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "hide");
}

void QTextEdit_HideDefault(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::hide();
}

void QTextEdit_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "lower");
}

void QTextEdit_LowerDefault(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::lower();
}

char QTextEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTextEdit*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QTextEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTextEdit*>(ptr)->QTextEdit::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QTextEdit_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "raise");
}

void QTextEdit_RaiseDefault(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::raise();
}

void QTextEdit_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "repaint");
}

void QTextEdit_RepaintDefault(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::repaint();
}

void QTextEdit_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QTextEdit_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::setDisabled(disable != 0);
}

void QTextEdit_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setFocus");
}

void QTextEdit_SetFocus2Default(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::setFocus();
}

void QTextEdit_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QTextEdit_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::setHidden(hidden != 0);
}

void QTextEdit_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "show");
}

void QTextEdit_ShowDefault(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::show();
}

void QTextEdit_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "showFullScreen");
}

void QTextEdit_ShowFullScreenDefault(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::showFullScreen();
}

void QTextEdit_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "showMaximized");
}

void QTextEdit_ShowMaximizedDefault(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::showMaximized();
}

void QTextEdit_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "showMinimized");
}

void QTextEdit_ShowMinimizedDefault(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::showMinimized();
}

void QTextEdit_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "showNormal");
}

void QTextEdit_ShowNormalDefault(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::showNormal();
}

void QTextEdit_TabletEvent(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTextEdit_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTextEdit_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "update");
}

void QTextEdit_UpdateDefault(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::update();
}

void QTextEdit_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "updateMicroFocus");
}

void QTextEdit_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::updateMicroFocus();
}

void QTextEdit_TimerEvent(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QTextEdit_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::timerEvent(static_cast<QTimerEvent*>(event));
}

void QTextEdit_ChildEvent(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QTextEdit_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::childEvent(static_cast<QChildEvent*>(event));
}

void QTextEdit_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QTextEdit*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTextEdit_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTextEdit_CustomEvent(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QTextEdit_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::customEvent(static_cast<QEvent*>(event));
}

void QTextEdit_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "deleteLater");
}

void QTextEdit_DeleteLaterDefault(void* ptr)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::deleteLater();
}

void QTextEdit_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QTextEdit*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTextEdit_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTextEdit*>(ptr)->QTextEdit::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QTextEdit_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QTextEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QTextEdit_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QTextEdit*>(ptr)->QTextEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QTextEdit_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTextEdit*>(ptr)->metaObject());
}

void* QTextEdit_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTextEdit*>(ptr)->QTextEdit::metaObject());
}

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));
}

long long QTileRules_Horizontal(void* ptr)
{
	return static_cast<QTileRules*>(ptr)->horizontal;
}

void QTileRules_SetHorizontal(void* ptr, long long vqt)
{
	static_cast<QTileRules*>(ptr)->horizontal = static_cast<Qt::TileRule>(vqt);
}

long long QTileRules_Vertical(void* ptr)
{
	return static_cast<QTileRules*>(ptr)->vertical;
}

void QTileRules_SetVertical(void* ptr, long long vqt)
{
	static_cast<QTileRules*>(ptr)->vertical = static_cast<Qt::TileRule>(vqt);
}

void* QTimeEdit_NewQTimeEdit(void* parent)
{
	return new QTimeEdit(static_cast<QWidget*>(parent));
}

void* QTimeEdit_NewQTimeEdit2(void* time, void* parent)
{
	return new QTimeEdit(*static_cast<QTime*>(time), static_cast<QWidget*>(parent));
}

void QTimeEdit_DestroyQTimeEdit(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->~QTimeEdit();
}

void QTimeEdit_SetDate(void* ptr, void* date)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setDate", Q_ARG(QDate, *static_cast<QDate*>(date)));
}

void QTimeEdit_SetDateDefault(void* ptr, void* date)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::setDate(*static_cast<QDate*>(date));
}

void QTimeEdit_SetDateTime(void* ptr, void* dateTime)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setDateTime", Q_ARG(QDateTime, *static_cast<QDateTime*>(dateTime)));
}

void QTimeEdit_SetDateTimeDefault(void* ptr, void* dateTime)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::setDateTime(*static_cast<QDateTime*>(dateTime));
}

void QTimeEdit_SetTime(void* ptr, void* time)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setTime", Q_ARG(QTime, *static_cast<QTime*>(time)));
}

void QTimeEdit_SetTimeDefault(void* ptr, void* time)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::setTime(*static_cast<QTime*>(time));
}

void QTimeEdit_Clear(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->clear();
}

void QTimeEdit_ClearDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::clear();
}

void* QTimeEdit_DateTimeFromText(void* ptr, char* text)
{
	return new QDateTime(static_cast<QTimeEdit*>(ptr)->dateTimeFromText(QString(text)));
}

void* QTimeEdit_DateTimeFromTextDefault(void* ptr, char* text)
{
	return new QDateTime(static_cast<QTimeEdit*>(ptr)->QTimeEdit::dateTimeFromText(QString(text)));
}

void QTimeEdit_Fixup(void* ptr, char* input)
{
	static_cast<QTimeEdit*>(ptr)->fixup(*(new QString(input)));
}

void QTimeEdit_FixupDefault(void* ptr, char* input)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::fixup(*(new QString(input)));
}

void QTimeEdit_FocusInEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QTimeEdit_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QTimeEdit_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QTimeEdit*>(ptr)->focusNextPrevChild(next != 0);
}

char QTimeEdit_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QTimeEdit*>(ptr)->QTimeEdit::focusNextPrevChild(next != 0);
}

void QTimeEdit_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QTimeEdit_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QTimeEdit_MousePressEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTimeEdit_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTimeEdit_PaintEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QTimeEdit_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::paintEvent(static_cast<QPaintEvent*>(event));
}

void* QTimeEdit_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTimeEdit*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTimeEdit_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTimeEdit*>(ptr)->QTimeEdit::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTimeEdit_StepBy(void* ptr, int steps)
{
	static_cast<QTimeEdit*>(ptr)->stepBy(steps);
}

void QTimeEdit_StepByDefault(void* ptr, int steps)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::stepBy(steps);
}

long long QTimeEdit_StepEnabled(void* ptr)
{
	return static_cast<QTimeEdit*>(ptr)->stepEnabled();
}

long long QTimeEdit_StepEnabledDefault(void* ptr)
{
	return static_cast<QTimeEdit*>(ptr)->QTimeEdit::stepEnabled();
}

char* QTimeEdit_TextFromDateTime(void* ptr, void* dateTime)
{
	return const_cast<char*>(static_cast<QTimeEdit*>(ptr)->textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QTimeEdit_TextFromDateTimeDefault(void* ptr, void* dateTime)
{
	return const_cast<char*>(static_cast<QTimeEdit*>(ptr)->QTimeEdit::textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8().prepend("WHITESPACE").constData()+10);
}

long long QTimeEdit_Validate(void* ptr, char* text, int pos)
{
	return static_cast<QTimeEdit*>(ptr)->validate(*(new QString(text)), pos);
}

long long QTimeEdit_ValidateDefault(void* ptr, char* text, int pos)
{
	return static_cast<QTimeEdit*>(ptr)->QTimeEdit::validate(*(new QString(text)), pos);
}

void QTimeEdit_WheelEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QTimeEdit_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QTimeEdit_ChangeEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QTimeEdit_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::changeEvent(static_cast<QEvent*>(event));
}

void QTimeEdit_CloseEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QTimeEdit_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::closeEvent(static_cast<QCloseEvent*>(event));
}

void QTimeEdit_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QTimeEdit_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QTimeEdit_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTimeEdit_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTimeEdit_HideEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QTimeEdit_HideEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::hideEvent(static_cast<QHideEvent*>(event));
}

void* QTimeEdit_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QTimeEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QTimeEdit_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QTimeEdit*>(ptr)->QTimeEdit::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QTimeEdit_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QTimeEdit_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void* QTimeEdit_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTimeEdit*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTimeEdit_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTimeEdit*>(ptr)->QTimeEdit::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTimeEdit_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTimeEdit_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTimeEdit_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QTimeEdit_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QTimeEdit_ResizeEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QTimeEdit_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QTimeEdit_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "selectAll");
}

void QTimeEdit_SelectAllDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::selectAll();
}

void QTimeEdit_ShowEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QTimeEdit_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::showEvent(static_cast<QShowEvent*>(event));
}

void QTimeEdit_StepDown(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "stepDown");
}

void QTimeEdit_StepDownDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::stepDown();
}

void QTimeEdit_StepUp(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "stepUp");
}

void QTimeEdit_StepUpDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::stepUp();
}

void QTimeEdit_ActionEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QTimeEdit_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::actionEvent(static_cast<QActionEvent*>(event));
}

void QTimeEdit_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTimeEdit_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTimeEdit_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QTimeEdit_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QTimeEdit_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QTimeEdit_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QTimeEdit_DropEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QTimeEdit_DropEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::dropEvent(static_cast<QDropEvent*>(event));
}

void QTimeEdit_EnterEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QTimeEdit_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::enterEvent(static_cast<QEvent*>(event));
}

void QTimeEdit_LeaveEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QTimeEdit_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::leaveEvent(static_cast<QEvent*>(event));
}

void QTimeEdit_MoveEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QTimeEdit_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::moveEvent(static_cast<QMoveEvent*>(event));
}

void QTimeEdit_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QTimeEdit_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::setEnabled(vbo != 0);
}

void QTimeEdit_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QTimeEdit_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::setStyleSheet(QString(styleSheet));
}

void QTimeEdit_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QTimeEdit_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::setVisible(visible != 0);
}

void QTimeEdit_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QTimeEdit_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::setWindowModified(vbo != 0);
}

void QTimeEdit_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QTimeEdit_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::setWindowTitle(QString(vqs));
}

char QTimeEdit_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QTimeEdit_CloseDefault(void* ptr)
{
	return static_cast<QTimeEdit*>(ptr)->QTimeEdit::close();
}

char QTimeEdit_HasHeightForWidth(void* ptr)
{
	return static_cast<QTimeEdit*>(ptr)->hasHeightForWidth();
}

char QTimeEdit_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QTimeEdit*>(ptr)->QTimeEdit::hasHeightForWidth();
}

int QTimeEdit_HeightForWidth(void* ptr, int w)
{
	return static_cast<QTimeEdit*>(ptr)->heightForWidth(w);
}

int QTimeEdit_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QTimeEdit*>(ptr)->QTimeEdit::heightForWidth(w);
}

void QTimeEdit_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "hide");
}

void QTimeEdit_HideDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::hide();
}

void QTimeEdit_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QTimeEdit_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QTimeEdit_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "lower");
}

void QTimeEdit_LowerDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::lower();
}

void QTimeEdit_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QTimeEdit_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QTimeEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTimeEdit*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QTimeEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTimeEdit*>(ptr)->QTimeEdit::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QTimeEdit_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "raise");
}

void QTimeEdit_RaiseDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::raise();
}

void QTimeEdit_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "repaint");
}

void QTimeEdit_RepaintDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::repaint();
}

void QTimeEdit_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QTimeEdit_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::setDisabled(disable != 0);
}

void QTimeEdit_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setFocus");
}

void QTimeEdit_SetFocus2Default(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::setFocus();
}

void QTimeEdit_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QTimeEdit_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::setHidden(hidden != 0);
}

void QTimeEdit_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "show");
}

void QTimeEdit_ShowDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::show();
}

void QTimeEdit_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "showFullScreen");
}

void QTimeEdit_ShowFullScreenDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::showFullScreen();
}

void QTimeEdit_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "showMaximized");
}

void QTimeEdit_ShowMaximizedDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::showMaximized();
}

void QTimeEdit_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "showMinimized");
}

void QTimeEdit_ShowMinimizedDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::showMinimized();
}

void QTimeEdit_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "showNormal");
}

void QTimeEdit_ShowNormalDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::showNormal();
}

void QTimeEdit_TabletEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTimeEdit_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTimeEdit_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "update");
}

void QTimeEdit_UpdateDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::update();
}

void QTimeEdit_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "updateMicroFocus");
}

void QTimeEdit_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::updateMicroFocus();
}

void QTimeEdit_ChildEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QTimeEdit_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::childEvent(static_cast<QChildEvent*>(event));
}

void QTimeEdit_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QTimeEdit*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTimeEdit_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTimeEdit_CustomEvent(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QTimeEdit_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::customEvent(static_cast<QEvent*>(event));
}

void QTimeEdit_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "deleteLater");
}

void QTimeEdit_DeleteLaterDefault(void* ptr)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::deleteLater();
}

void QTimeEdit_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QTimeEdit*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTimeEdit_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTimeEdit*>(ptr)->QTimeEdit::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QTimeEdit_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QTimeEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QTimeEdit_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QTimeEdit*>(ptr)->QTimeEdit::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QTimeEdit_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTimeEdit*>(ptr)->metaObject());
}

void* QTimeEdit_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTimeEdit*>(ptr)->QTimeEdit::metaObject());
}

class MyQToolBar: public QToolBar
{
public:
	MyQToolBar(QWidget *parent) : QToolBar(parent) {};
	MyQToolBar(const QString &title, QWidget *parent) : QToolBar(title, parent) {};
	void setIconSize(const QSize & iconSize) { callbackQToolBar_SetIconSize(this, const_cast<QSize*>(&iconSize)); };
	void setToolButtonStyle(Qt::ToolButtonStyle toolButtonStyle) { callbackQToolBar_SetToolButtonStyle(this, toolButtonStyle); };
	void actionEvent(QActionEvent * event) { callbackQToolBar_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) { callbackQToolBar_ChangeEvent(this, event); };
	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) { callbackQToolBar_PaintEvent(this, event); };
	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); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQToolBar_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQToolBar_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQToolBar_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQToolBar_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQToolBar_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQToolBar_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQToolBar_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQToolBar_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQToolBar_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQToolBar_MinimumSizeHint(const_cast<MyQToolBar*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQToolBar_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQToolBar_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQToolBar_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQToolBar_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQToolBar_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQToolBar_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQToolBar_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQToolBar_SizeHint(const_cast<MyQToolBar*>(this))); };
	bool close() { return callbackQToolBar_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQToolBar_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQToolBar_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQToolBar_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQToolBar_HasHeightForWidth(const_cast<MyQToolBar*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQToolBar_HeightForWidth(const_cast<MyQToolBar*>(this), w); };
	void hide() { callbackQToolBar_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQToolBar_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQToolBar_InputMethodQuery(const_cast<MyQToolBar*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQToolBar_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQToolBar_KeyReleaseEvent(this, event); };
	void lower() { callbackQToolBar_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQToolBar_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQToolBar_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQToolBar_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQToolBar_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQToolBar_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQToolBar_Raise(this); };
	void repaint() { callbackQToolBar_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQToolBar_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQToolBar_SetDisabled(this, disable); };
	void setFocus() { callbackQToolBar_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQToolBar_SetHidden(this, hidden); };
	void show() { callbackQToolBar_Show(this); };
	void showFullScreen() { callbackQToolBar_ShowFullScreen(this); };
	void showMaximized() { callbackQToolBar_ShowMaximized(this); };
	void showMinimized() { callbackQToolBar_ShowMinimized(this); };
	void showNormal() { callbackQToolBar_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQToolBar_TabletEvent(this, event); };
	void update() { callbackQToolBar_Update(this); };
	void updateMicroFocus() { callbackQToolBar_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQToolBar_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQToolBar_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQToolBar_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQToolBar_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQToolBar_CustomEvent(this, event); };
	void deleteLater() { callbackQToolBar_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQToolBar_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQToolBar_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQToolBar_MetaObject(const_cast<MyQToolBar*>(this))); };
};

long long QToolBar_AllowedAreas(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->allowedAreas();
}

void* QToolBar_IconSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolBar*>(ptr)->iconSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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();
}

long long QToolBar_Orientation(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->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(QSize, *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)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setToolButtonStyle", Q_ARG(Qt::ToolButtonStyle, static_cast<Qt::ToolButtonStyle>(toolButtonStyle)));
}

long long QToolBar_ToolButtonStyle(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->toolButtonStyle();
}

void* QToolBar_NewQToolBar2(void* parent)
{
	return new MyQToolBar(static_cast<QWidget*>(parent));
}

void* QToolBar_NewQToolBar(char* title, void* parent)
{
	return new MyQToolBar(QString(title), 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_ActionEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QToolBar_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::actionEvent(static_cast<QActionEvent*>(event));
}

void QToolBar_ConnectActionTriggered(void* ptr)
{
	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));
}

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_AddAction2(void* ptr, void* icon, char* text)
{
	return static_cast<QToolBar*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString(text));
}

void* QToolBar_AddAction4(void* ptr, void* icon, char* text, void* receiver, char* member)
{
	return static_cast<QToolBar*>(ptr)->addAction(*static_cast<QIcon*>(icon), QString(text), static_cast<QObject*>(receiver), const_cast<const char*>(member));
}

void* QToolBar_AddAction(void* ptr, char* text)
{
	return static_cast<QToolBar*>(ptr)->addAction(QString(text));
}

void* QToolBar_AddAction3(void* ptr, char* text, void* receiver, char* member)
{
	return static_cast<QToolBar*>(ptr)->addAction(QString(text), 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));
}

void QToolBar_ConnectAllowedAreasChanged(void* ptr)
{
	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));
}

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_ChangeEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QToolBar_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::changeEvent(static_cast<QEvent*>(event));
}

void QToolBar_Clear(void* ptr)
{
	static_cast<QToolBar*>(ptr)->clear();
}

char QToolBar_Event(void* ptr, void* event)
{
	return static_cast<QToolBar*>(ptr)->event(static_cast<QEvent*>(event));
}

void QToolBar_ConnectIconSizeChanged(void* ptr)
{
	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));
}

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));
}

void QToolBar_ConnectMovableChanged(void* ptr)
{
	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));
}

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);
}

void QToolBar_ConnectOrientationChanged(void* ptr)
{
	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));
}

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_PaintEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QToolBar_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::paintEvent(static_cast<QPaintEvent*>(event));
}

void* QToolBar_ToggleViewAction(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->toggleViewAction();
}

void QToolBar_ConnectToolButtonStyleChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QToolBar_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QToolBar_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QToolBar_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QToolBar_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QToolBar_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QToolBar_DropEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QToolBar_DropEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::dropEvent(static_cast<QDropEvent*>(event));
}

void QToolBar_EnterEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QToolBar_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::enterEvent(static_cast<QEvent*>(event));
}

void QToolBar_FocusInEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QToolBar_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QToolBar_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QToolBar_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QToolBar_HideEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QToolBar_HideEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::hideEvent(static_cast<QHideEvent*>(event));
}

void QToolBar_LeaveEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QToolBar_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::leaveEvent(static_cast<QEvent*>(event));
}

void* QToolBar_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolBar*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QToolBar_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolBar*>(ptr)->QToolBar::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QToolBar_MoveEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QToolBar_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::moveEvent(static_cast<QMoveEvent*>(event));
}

void QToolBar_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QToolBar_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QToolBar*>(ptr)->QToolBar::setEnabled(vbo != 0);
}

void QToolBar_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QToolBar_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QToolBar*>(ptr)->QToolBar::setStyleSheet(QString(styleSheet));
}

void QToolBar_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QToolBar_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QToolBar*>(ptr)->QToolBar::setVisible(visible != 0);
}

void QToolBar_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QToolBar_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QToolBar*>(ptr)->QToolBar::setWindowModified(vbo != 0);
}

void QToolBar_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QToolBar_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QToolBar*>(ptr)->QToolBar::setWindowTitle(QString(vqs));
}

void QToolBar_ShowEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QToolBar_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::showEvent(static_cast<QShowEvent*>(event));
}

void* QToolBar_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolBar*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QToolBar_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolBar*>(ptr)->QToolBar::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

char QToolBar_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QToolBar_CloseDefault(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->QToolBar::close();
}

void QToolBar_CloseEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QToolBar_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::closeEvent(static_cast<QCloseEvent*>(event));
}

void QToolBar_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QToolBar_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QToolBar_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QToolBar*>(ptr)->focusNextPrevChild(next != 0);
}

char QToolBar_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QToolBar*>(ptr)->QToolBar::focusNextPrevChild(next != 0);
}

char QToolBar_HasHeightForWidth(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->hasHeightForWidth();
}

char QToolBar_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QToolBar*>(ptr)->QToolBar::hasHeightForWidth();
}

int QToolBar_HeightForWidth(void* ptr, int w)
{
	return static_cast<QToolBar*>(ptr)->heightForWidth(w);
}

int QToolBar_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QToolBar*>(ptr)->QToolBar::heightForWidth(w);
}

void QToolBar_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "hide");
}

void QToolBar_HideDefault(void* ptr)
{
	static_cast<QToolBar*>(ptr)->QToolBar::hide();
}

void QToolBar_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QToolBar_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QToolBar_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QToolBar*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QToolBar_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QToolBar*>(ptr)->QToolBar::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QToolBar_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QToolBar_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QToolBar_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QToolBar_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QToolBar_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "lower");
}

void QToolBar_LowerDefault(void* ptr)
{
	static_cast<QToolBar*>(ptr)->QToolBar::lower();
}

void QToolBar_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QToolBar_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QToolBar_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QToolBar_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QToolBar_MousePressEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QToolBar_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QToolBar_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QToolBar_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QToolBar_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QToolBar*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QToolBar_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QToolBar*>(ptr)->QToolBar::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QToolBar_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "raise");
}

void QToolBar_RaiseDefault(void* ptr)
{
	static_cast<QToolBar*>(ptr)->QToolBar::raise();
}

void QToolBar_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "repaint");
}

void QToolBar_RepaintDefault(void* ptr)
{
	static_cast<QToolBar*>(ptr)->QToolBar::repaint();
}

void QToolBar_ResizeEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QToolBar_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QToolBar_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QToolBar_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QToolBar*>(ptr)->QToolBar::setDisabled(disable != 0);
}

void QToolBar_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setFocus");
}

void QToolBar_SetFocus2Default(void* ptr)
{
	static_cast<QToolBar*>(ptr)->QToolBar::setFocus();
}

void QToolBar_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QToolBar_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QToolBar*>(ptr)->QToolBar::setHidden(hidden != 0);
}

void QToolBar_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "show");
}

void QToolBar_ShowDefault(void* ptr)
{
	static_cast<QToolBar*>(ptr)->QToolBar::show();
}

void QToolBar_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "showFullScreen");
}

void QToolBar_ShowFullScreenDefault(void* ptr)
{
	static_cast<QToolBar*>(ptr)->QToolBar::showFullScreen();
}

void QToolBar_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "showMaximized");
}

void QToolBar_ShowMaximizedDefault(void* ptr)
{
	static_cast<QToolBar*>(ptr)->QToolBar::showMaximized();
}

void QToolBar_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "showMinimized");
}

void QToolBar_ShowMinimizedDefault(void* ptr)
{
	static_cast<QToolBar*>(ptr)->QToolBar::showMinimized();
}

void QToolBar_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "showNormal");
}

void QToolBar_ShowNormalDefault(void* ptr)
{
	static_cast<QToolBar*>(ptr)->QToolBar::showNormal();
}

void QToolBar_TabletEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QToolBar_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QToolBar_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "update");
}

void QToolBar_UpdateDefault(void* ptr)
{
	static_cast<QToolBar*>(ptr)->QToolBar::update();
}

void QToolBar_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "updateMicroFocus");
}

void QToolBar_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QToolBar*>(ptr)->QToolBar::updateMicroFocus();
}

void QToolBar_WheelEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QToolBar_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QToolBar_TimerEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QToolBar_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::timerEvent(static_cast<QTimerEvent*>(event));
}

void QToolBar_ChildEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QToolBar_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::childEvent(static_cast<QChildEvent*>(event));
}

void QToolBar_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QToolBar*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QToolBar_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QToolBar*>(ptr)->QToolBar::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QToolBar_CustomEvent(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QToolBar_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QToolBar*>(ptr)->QToolBar::customEvent(static_cast<QEvent*>(event));
}

void QToolBar_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "deleteLater");
}

void QToolBar_DeleteLaterDefault(void* ptr)
{
	static_cast<QToolBar*>(ptr)->QToolBar::deleteLater();
}

void QToolBar_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QToolBar*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QToolBar_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QToolBar*>(ptr)->QToolBar::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QToolBar_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QToolBar*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QToolBar_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QToolBar*>(ptr)->QToolBar::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QToolBar_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QToolBar*>(ptr)->metaObject());
}

void* QToolBar_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QToolBar*>(ptr)->QToolBar::metaObject());
}

class MyQToolBox: public QToolBox
{
public:
	MyQToolBox(QWidget *parent, Qt::WindowFlags f) : QToolBox(parent, f) {};
	void setCurrentIndex(int index) { callbackQToolBox_SetCurrentIndex(this, index); };
	void changeEvent(QEvent * ev) { callbackQToolBox_ChangeEvent(this, ev); };
	void Signal_CurrentChanged(int index) { callbackQToolBox_CurrentChanged(this, index); };
	void itemInserted(int index) { callbackQToolBox_ItemInserted(this, index); };
	void itemRemoved(int index) { callbackQToolBox_ItemRemoved(this, index); };
	void setCurrentWidget(QWidget * widget) { callbackQToolBox_SetCurrentWidget(this, widget); };
	void showEvent(QShowEvent * e) { callbackQToolBox_ShowEvent(this, e); };
	void paintEvent(QPaintEvent * vqp) { callbackQToolBox_PaintEvent(this, vqp); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQToolBox_SizeHint(const_cast<MyQToolBox*>(this))); };
	void actionEvent(QActionEvent * event) { callbackQToolBox_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQToolBox_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQToolBox_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQToolBox_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQToolBox_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQToolBox_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQToolBox_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQToolBox_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQToolBox_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQToolBox_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQToolBox_MinimumSizeHint(const_cast<MyQToolBox*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQToolBox_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQToolBox_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQToolBox_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQToolBox_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQToolBox_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQToolBox_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	bool close() { return callbackQToolBox_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQToolBox_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQToolBox_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQToolBox_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQToolBox_HasHeightForWidth(const_cast<MyQToolBox*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQToolBox_HeightForWidth(const_cast<MyQToolBox*>(this), w); };
	void hide() { callbackQToolBox_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQToolBox_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQToolBox_InputMethodQuery(const_cast<MyQToolBox*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQToolBox_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQToolBox_KeyReleaseEvent(this, event); };
	void lower() { callbackQToolBox_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQToolBox_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQToolBox_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQToolBox_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQToolBox_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQToolBox_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQToolBox_Raise(this); };
	void repaint() { callbackQToolBox_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQToolBox_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQToolBox_SetDisabled(this, disable); };
	void setFocus() { callbackQToolBox_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQToolBox_SetHidden(this, hidden); };
	void show() { callbackQToolBox_Show(this); };
	void showFullScreen() { callbackQToolBox_ShowFullScreen(this); };
	void showMaximized() { callbackQToolBox_ShowMaximized(this); };
	void showMinimized() { callbackQToolBox_ShowMinimized(this); };
	void showNormal() { callbackQToolBox_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQToolBox_TabletEvent(this, event); };
	void update() { callbackQToolBox_Update(this); };
	void updateMicroFocus() { callbackQToolBox_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQToolBox_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQToolBox_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQToolBox_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQToolBox_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQToolBox_CustomEvent(this, event); };
	void deleteLater() { callbackQToolBox_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQToolBox_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQToolBox_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQToolBox_MetaObject(const_cast<MyQToolBox*>(this))); };
};

int QToolBox_Count(void* ptr)
{
	return static_cast<QToolBox*>(ptr)->count();
}

int QToolBox_CurrentIndex(void* ptr)
{
	return static_cast<QToolBox*>(ptr)->currentIndex();
}

void QToolBox_SetCurrentIndex(void* ptr, int index)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setCurrentIndex", Q_ARG(int, index));
}

void* QToolBox_NewQToolBox(void* parent, long long f)
{
	return new MyQToolBox(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
}

int QToolBox_AddItem2(void* ptr, void* w, char* text)
{
	return static_cast<QToolBox*>(ptr)->addItem(static_cast<QWidget*>(w), QString(text));
}

int QToolBox_AddItem(void* ptr, void* widget, void* iconSet, char* text)
{
	return static_cast<QToolBox*>(ptr)->addItem(static_cast<QWidget*>(widget), *static_cast<QIcon*>(iconSet), QString(text));
}

void QToolBox_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QToolBox*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QToolBox_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QToolBox*>(ptr)->QToolBox::changeEvent(static_cast<QEvent*>(ev));
}

void QToolBox_ConnectCurrentChanged(void* ptr)
{
	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));
}

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);
}

void* QToolBox_CurrentWidget(void* ptr)
{
	return static_cast<QToolBox*>(ptr)->currentWidget();
}

char QToolBox_Event(void* ptr, void* e)
{
	return static_cast<QToolBox*>(ptr)->event(static_cast<QEvent*>(e));
}

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, char* text)
{
	return static_cast<QToolBox*>(ptr)->insertItem(index, static_cast<QWidget*>(widget), *static_cast<QIcon*>(icon), QString(text));
}

int QToolBox_InsertItem2(void* ptr, int index, void* widget, char* text)
{
	return static_cast<QToolBox*>(ptr)->insertItem(index, static_cast<QWidget*>(widget), QString(text));
}

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);
}

char* QToolBox_ItemText(void* ptr, int index)
{
	return const_cast<char*>(static_cast<QToolBox*>(ptr)->itemText(index).toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QToolBox_ItemToolTip(void* ptr, int index)
{
	return const_cast<char*>(static_cast<QToolBox*>(ptr)->itemToolTip(index).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QToolBox_RemoveItem(void* ptr, int index)
{
	static_cast<QToolBox*>(ptr)->removeItem(index);
}

void QToolBox_SetCurrentWidget(void* ptr, void* widget)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setCurrentWidget", Q_ARG(QWidget*, 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, char* text)
{
	static_cast<QToolBox*>(ptr)->setItemText(index, QString(text));
}

void QToolBox_SetItemToolTip(void* ptr, int index, char* toolTip)
{
	static_cast<QToolBox*>(ptr)->setItemToolTip(index, QString(toolTip));
}

void QToolBox_ShowEvent(void* ptr, void* e)
{
	static_cast<QToolBox*>(ptr)->showEvent(static_cast<QShowEvent*>(e));
}

void QToolBox_ShowEventDefault(void* ptr, void* e)
{
	static_cast<QToolBox*>(ptr)->QToolBox::showEvent(static_cast<QShowEvent*>(e));
}

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_PaintEvent(void* ptr, void* vqp)
{
	static_cast<QToolBox*>(ptr)->paintEvent(static_cast<QPaintEvent*>(vqp));
}

void QToolBox_PaintEventDefault(void* ptr, void* vqp)
{
	static_cast<QToolBox*>(ptr)->QToolBox::paintEvent(static_cast<QPaintEvent*>(vqp));
}

void* QToolBox_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolBox*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QToolBox_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolBox*>(ptr)->QToolBox::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QToolBox_ActionEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QToolBox_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::actionEvent(static_cast<QActionEvent*>(event));
}

void QToolBox_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QToolBox_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QToolBox_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QToolBox_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QToolBox_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QToolBox_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QToolBox_DropEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QToolBox_DropEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::dropEvent(static_cast<QDropEvent*>(event));
}

void QToolBox_EnterEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QToolBox_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::enterEvent(static_cast<QEvent*>(event));
}

void QToolBox_FocusInEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QToolBox_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QToolBox_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QToolBox_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QToolBox_HideEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QToolBox_HideEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::hideEvent(static_cast<QHideEvent*>(event));
}

void QToolBox_LeaveEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QToolBox_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::leaveEvent(static_cast<QEvent*>(event));
}

void* QToolBox_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolBox*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QToolBox_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolBox*>(ptr)->QToolBox::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QToolBox_MoveEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QToolBox_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::moveEvent(static_cast<QMoveEvent*>(event));
}

void QToolBox_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QToolBox_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QToolBox*>(ptr)->QToolBox::setEnabled(vbo != 0);
}

void QToolBox_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QToolBox_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QToolBox*>(ptr)->QToolBox::setStyleSheet(QString(styleSheet));
}

void QToolBox_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QToolBox_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QToolBox*>(ptr)->QToolBox::setVisible(visible != 0);
}

void QToolBox_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QToolBox_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QToolBox*>(ptr)->QToolBox::setWindowModified(vbo != 0);
}

void QToolBox_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QToolBox_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QToolBox*>(ptr)->QToolBox::setWindowTitle(QString(vqs));
}

char QToolBox_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QToolBox_CloseDefault(void* ptr)
{
	return static_cast<QToolBox*>(ptr)->QToolBox::close();
}

void QToolBox_CloseEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QToolBox_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::closeEvent(static_cast<QCloseEvent*>(event));
}

void QToolBox_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QToolBox_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QToolBox_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QToolBox*>(ptr)->focusNextPrevChild(next != 0);
}

char QToolBox_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QToolBox*>(ptr)->QToolBox::focusNextPrevChild(next != 0);
}

char QToolBox_HasHeightForWidth(void* ptr)
{
	return static_cast<QToolBox*>(ptr)->hasHeightForWidth();
}

char QToolBox_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QToolBox*>(ptr)->QToolBox::hasHeightForWidth();
}

int QToolBox_HeightForWidth(void* ptr, int w)
{
	return static_cast<QToolBox*>(ptr)->heightForWidth(w);
}

int QToolBox_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QToolBox*>(ptr)->QToolBox::heightForWidth(w);
}

void QToolBox_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "hide");
}

void QToolBox_HideDefault(void* ptr)
{
	static_cast<QToolBox*>(ptr)->QToolBox::hide();
}

void QToolBox_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QToolBox_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QToolBox_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QToolBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QToolBox_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QToolBox*>(ptr)->QToolBox::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QToolBox_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QToolBox_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QToolBox_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QToolBox_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QToolBox_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "lower");
}

void QToolBox_LowerDefault(void* ptr)
{
	static_cast<QToolBox*>(ptr)->QToolBox::lower();
}

void QToolBox_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QToolBox_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QToolBox_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QToolBox_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QToolBox_MousePressEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QToolBox_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QToolBox_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QToolBox_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QToolBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QToolBox*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QToolBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QToolBox*>(ptr)->QToolBox::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QToolBox_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "raise");
}

void QToolBox_RaiseDefault(void* ptr)
{
	static_cast<QToolBox*>(ptr)->QToolBox::raise();
}

void QToolBox_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "repaint");
}

void QToolBox_RepaintDefault(void* ptr)
{
	static_cast<QToolBox*>(ptr)->QToolBox::repaint();
}

void QToolBox_ResizeEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QToolBox_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QToolBox_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QToolBox_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QToolBox*>(ptr)->QToolBox::setDisabled(disable != 0);
}

void QToolBox_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setFocus");
}

void QToolBox_SetFocus2Default(void* ptr)
{
	static_cast<QToolBox*>(ptr)->QToolBox::setFocus();
}

void QToolBox_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QToolBox_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QToolBox*>(ptr)->QToolBox::setHidden(hidden != 0);
}

void QToolBox_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "show");
}

void QToolBox_ShowDefault(void* ptr)
{
	static_cast<QToolBox*>(ptr)->QToolBox::show();
}

void QToolBox_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "showFullScreen");
}

void QToolBox_ShowFullScreenDefault(void* ptr)
{
	static_cast<QToolBox*>(ptr)->QToolBox::showFullScreen();
}

void QToolBox_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "showMaximized");
}

void QToolBox_ShowMaximizedDefault(void* ptr)
{
	static_cast<QToolBox*>(ptr)->QToolBox::showMaximized();
}

void QToolBox_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "showMinimized");
}

void QToolBox_ShowMinimizedDefault(void* ptr)
{
	static_cast<QToolBox*>(ptr)->QToolBox::showMinimized();
}

void QToolBox_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "showNormal");
}

void QToolBox_ShowNormalDefault(void* ptr)
{
	static_cast<QToolBox*>(ptr)->QToolBox::showNormal();
}

void QToolBox_TabletEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QToolBox_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QToolBox_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "update");
}

void QToolBox_UpdateDefault(void* ptr)
{
	static_cast<QToolBox*>(ptr)->QToolBox::update();
}

void QToolBox_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "updateMicroFocus");
}

void QToolBox_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QToolBox*>(ptr)->QToolBox::updateMicroFocus();
}

void QToolBox_WheelEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QToolBox_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QToolBox_TimerEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QToolBox_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::timerEvent(static_cast<QTimerEvent*>(event));
}

void QToolBox_ChildEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QToolBox_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::childEvent(static_cast<QChildEvent*>(event));
}

void QToolBox_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QToolBox*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QToolBox_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QToolBox*>(ptr)->QToolBox::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QToolBox_CustomEvent(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QToolBox_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QToolBox*>(ptr)->QToolBox::customEvent(static_cast<QEvent*>(event));
}

void QToolBox_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "deleteLater");
}

void QToolBox_DeleteLaterDefault(void* ptr)
{
	static_cast<QToolBox*>(ptr)->QToolBox::deleteLater();
}

void QToolBox_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QToolBox*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QToolBox_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QToolBox*>(ptr)->QToolBox::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QToolBox_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QToolBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QToolBox_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QToolBox*>(ptr)->QToolBox::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QToolBox_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QToolBox*>(ptr)->metaObject());
}

void* QToolBox_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QToolBox*>(ptr)->QToolBox::metaObject());
}

class MyQToolButton: public QToolButton
{
public:
	MyQToolButton(QWidget *parent) : QToolButton(parent) {};
	void paintEvent(QPaintEvent * event) { callbackQToolButton_PaintEvent(this, event); };
	void setToolButtonStyle(Qt::ToolButtonStyle style) { callbackQToolButton_SetToolButtonStyle(this, style); };
	void actionEvent(QActionEvent * event) { callbackQToolButton_ActionEvent(this, event); };
	void changeEvent(QEvent * e) { callbackQToolButton_ChangeEvent(this, e); };
	void enterEvent(QEvent * e) { callbackQToolButton_EnterEvent(this, e); };
	bool hitButton(const QPoint & pos) const { return callbackQToolButton_HitButton(const_cast<MyQToolButton*>(this), const_cast<QPoint*>(&pos)) != 0; };
	void leaveEvent(QEvent * e) { callbackQToolButton_LeaveEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQToolButton_MinimumSizeHint(const_cast<MyQToolButton*>(this))); };
	void mousePressEvent(QMouseEvent * e) { callbackQToolButton_MousePressEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQToolButton_MouseReleaseEvent(this, e); };
	void nextCheckState() { callbackQToolButton_NextCheckState(this); };
	void setDefaultAction(QAction * action) { callbackQToolButton_SetDefaultAction(this, action); };
	void showMenu() { callbackQToolButton_ShowMenu(this); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQToolButton_SizeHint(const_cast<MyQToolButton*>(this))); };
	void Signal_Triggered(QAction * action) { callbackQToolButton_Triggered(this, action); };
	void setChecked(bool vbo) { callbackQToolButton_SetChecked(this, vbo); };
	void setIconSize(const QSize & size) { callbackQToolButton_SetIconSize(this, const_cast<QSize*>(&size)); };
	void toggle() { callbackQToolButton_Toggle(this); };
	void animateClick(int msec) { callbackQToolButton_AnimateClick(this, msec); };
	void checkStateSet() { callbackQToolButton_CheckStateSet(this); };
	void click() { callbackQToolButton_Click(this); };
	void focusInEvent(QFocusEvent * e) { callbackQToolButton_FocusInEvent(this, e); };
	void focusOutEvent(QFocusEvent * e) { callbackQToolButton_FocusOutEvent(this, e); };
	void keyPressEvent(QKeyEvent * e) { callbackQToolButton_KeyPressEvent(this, e); };
	void keyReleaseEvent(QKeyEvent * e) { callbackQToolButton_KeyReleaseEvent(this, e); };
	void mouseMoveEvent(QMouseEvent * e) { callbackQToolButton_MouseMoveEvent(this, e); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQToolButton_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQToolButton_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQToolButton_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQToolButton_DropEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQToolButton_HideEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQToolButton_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQToolButton_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQToolButton_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQToolButton_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQToolButton_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQToolButton_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQToolButton_ShowEvent(this, event); };
	bool close() { return callbackQToolButton_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQToolButton_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQToolButton_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQToolButton_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQToolButton_HasHeightForWidth(const_cast<MyQToolButton*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQToolButton_HeightForWidth(const_cast<MyQToolButton*>(this), w); };
	void hide() { callbackQToolButton_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQToolButton_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQToolButton_InputMethodQuery(const_cast<MyQToolButton*>(this), query)); };
	void lower() { callbackQToolButton_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQToolButton_MouseDoubleClickEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQToolButton_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQToolButton_Raise(this); };
	void repaint() { callbackQToolButton_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQToolButton_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQToolButton_SetDisabled(this, disable); };
	void setFocus() { callbackQToolButton_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQToolButton_SetHidden(this, hidden); };
	void show() { callbackQToolButton_Show(this); };
	void showFullScreen() { callbackQToolButton_ShowFullScreen(this); };
	void showMaximized() { callbackQToolButton_ShowMaximized(this); };
	void showMinimized() { callbackQToolButton_ShowMinimized(this); };
	void showNormal() { callbackQToolButton_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQToolButton_TabletEvent(this, event); };
	void update() { callbackQToolButton_Update(this); };
	void updateMicroFocus() { callbackQToolButton_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQToolButton_WheelEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQToolButton_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQToolButton_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQToolButton_CustomEvent(this, event); };
	void deleteLater() { callbackQToolButton_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQToolButton_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQToolButton_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQToolButton_MetaObject(const_cast<MyQToolButton*>(this))); };
};

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_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_SetPopupMode(void* ptr, long long mode)
{
	static_cast<QToolButton*>(ptr)->setPopupMode(static_cast<QToolButton::ToolButtonPopupMode>(mode));
}

void QToolButton_SetToolButtonStyle(void* ptr, long long style)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setToolButtonStyle", Q_ARG(Qt::ToolButtonStyle, static_cast<Qt::ToolButtonStyle>(style)));
}

long long QToolButton_ToolButtonStyle(void* ptr)
{
	return static_cast<QToolButton*>(ptr)->toolButtonStyle();
}

void* QToolButton_NewQToolButton(void* parent)
{
	return new MyQToolButton(static_cast<QWidget*>(parent));
}

void QToolButton_ActionEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QToolButton_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::actionEvent(static_cast<QActionEvent*>(event));
}

void QToolButton_ChangeEvent(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->changeEvent(static_cast<QEvent*>(e));
}

void QToolButton_ChangeEventDefault(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->QToolButton::changeEvent(static_cast<QEvent*>(e));
}

void* QToolButton_DefaultAction(void* ptr)
{
	return static_cast<QToolButton*>(ptr)->defaultAction();
}

void QToolButton_EnterEvent(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->enterEvent(static_cast<QEvent*>(e));
}

void QToolButton_EnterEventDefault(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->QToolButton::enterEvent(static_cast<QEvent*>(e));
}

char QToolButton_Event(void* ptr, void* event)
{
	return static_cast<QToolButton*>(ptr)->event(static_cast<QEvent*>(event));
}

char QToolButton_HitButton(void* ptr, void* pos)
{
	return static_cast<QToolButton*>(ptr)->hitButton(*static_cast<QPoint*>(pos));
}

char QToolButton_HitButtonDefault(void* ptr, void* pos)
{
	return static_cast<QToolButton*>(ptr)->QToolButton::hitButton(*static_cast<QPoint*>(pos));
}

void QToolButton_InitStyleOption(void* ptr, void* option)
{
	static_cast<QToolButton*>(ptr)->initStyleOption(static_cast<QStyleOptionToolButton*>(option));
}

void QToolButton_LeaveEvent(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->leaveEvent(static_cast<QEvent*>(e));
}

void QToolButton_LeaveEventDefault(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->QToolButton::leaveEvent(static_cast<QEvent*>(e));
}

void* QToolButton_Menu(void* ptr)
{
	return static_cast<QToolButton*>(ptr)->menu();
}

void* QToolButton_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolButton*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QToolButton_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolButton*>(ptr)->QToolButton::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QToolButton_MousePressEvent(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QToolButton_MousePressEventDefault(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->QToolButton::mousePressEvent(static_cast<QMouseEvent*>(e));
}

void QToolButton_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QToolButton_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->QToolButton::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QToolButton_NextCheckState(void* ptr)
{
	static_cast<QToolButton*>(ptr)->nextCheckState();
}

void QToolButton_NextCheckStateDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::nextCheckState();
}

void QToolButton_SetDefaultAction(void* ptr, void* action)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setDefaultAction", Q_ARG(QAction*, static_cast<QAction*>(action)));
}

void QToolButton_SetMenu(void* ptr, void* menu)
{
	static_cast<QToolButton*>(ptr)->setMenu(static_cast<QMenu*>(menu));
}

void QToolButton_ShowMenu(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "showMenu");
}

void* QToolButton_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolButton*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QToolButton_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QToolButton*>(ptr)->QToolButton::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QToolButton_TimerEvent(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->timerEvent(static_cast<QTimerEvent*>(e));
}

void QToolButton_ConnectTriggered(void* ptr)
{
	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));
}

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_SetChecked(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}

void QToolButton_SetCheckedDefault(void* ptr, char vbo)
{
	static_cast<QToolButton*>(ptr)->QToolButton::setChecked(vbo != 0);
}

void QToolButton_SetIconSize(void* ptr, void* size)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setIconSize", Q_ARG(QSize, *static_cast<QSize*>(size)));
}

void QToolButton_SetIconSizeDefault(void* ptr, void* size)
{
	static_cast<QToolButton*>(ptr)->QToolButton::setIconSize(*static_cast<QSize*>(size));
}

void QToolButton_Toggle(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "toggle");
}

void QToolButton_ToggleDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::toggle();
}

void QToolButton_AnimateClick(void* ptr, int msec)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "animateClick", Q_ARG(int, msec));
}

void QToolButton_AnimateClickDefault(void* ptr, int msec)
{
	static_cast<QToolButton*>(ptr)->QToolButton::animateClick(msec);
}

void QToolButton_CheckStateSet(void* ptr)
{
	static_cast<QToolButton*>(ptr)->checkStateSet();
}

void QToolButton_CheckStateSetDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::checkStateSet();
}

void QToolButton_Click(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "click");
}

void QToolButton_ClickDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::click();
}

void QToolButton_FocusInEvent(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(e));
}

void QToolButton_FocusInEventDefault(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->QToolButton::focusInEvent(static_cast<QFocusEvent*>(e));
}

void QToolButton_FocusOutEvent(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QToolButton_FocusOutEventDefault(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->QToolButton::focusOutEvent(static_cast<QFocusEvent*>(e));
}

void QToolButton_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QToolButton_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->QToolButton::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QToolButton_KeyReleaseEvent(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QToolButton_KeyReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->QToolButton::keyReleaseEvent(static_cast<QKeyEvent*>(e));
}

void QToolButton_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QToolButton_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QToolButton*>(ptr)->QToolButton::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QToolButton_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QToolButton_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QToolButton_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QToolButton_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QToolButton_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QToolButton_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QToolButton_DropEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QToolButton_DropEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::dropEvent(static_cast<QDropEvent*>(event));
}

void QToolButton_HideEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QToolButton_HideEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::hideEvent(static_cast<QHideEvent*>(event));
}

void QToolButton_MoveEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QToolButton_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::moveEvent(static_cast<QMoveEvent*>(event));
}

void QToolButton_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QToolButton_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QToolButton*>(ptr)->QToolButton::setEnabled(vbo != 0);
}

void QToolButton_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QToolButton_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QToolButton*>(ptr)->QToolButton::setStyleSheet(QString(styleSheet));
}

void QToolButton_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QToolButton_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QToolButton*>(ptr)->QToolButton::setVisible(visible != 0);
}

void QToolButton_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QToolButton_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QToolButton*>(ptr)->QToolButton::setWindowModified(vbo != 0);
}

void QToolButton_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QToolButton_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QToolButton*>(ptr)->QToolButton::setWindowTitle(QString(vqs));
}

void QToolButton_ShowEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QToolButton_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::showEvent(static_cast<QShowEvent*>(event));
}

char QToolButton_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QToolButton_CloseDefault(void* ptr)
{
	return static_cast<QToolButton*>(ptr)->QToolButton::close();
}

void QToolButton_CloseEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QToolButton_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::closeEvent(static_cast<QCloseEvent*>(event));
}

void QToolButton_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QToolButton_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QToolButton_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QToolButton*>(ptr)->focusNextPrevChild(next != 0);
}

char QToolButton_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QToolButton*>(ptr)->QToolButton::focusNextPrevChild(next != 0);
}

char QToolButton_HasHeightForWidth(void* ptr)
{
	return static_cast<QToolButton*>(ptr)->hasHeightForWidth();
}

char QToolButton_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QToolButton*>(ptr)->QToolButton::hasHeightForWidth();
}

int QToolButton_HeightForWidth(void* ptr, int w)
{
	return static_cast<QToolButton*>(ptr)->heightForWidth(w);
}

int QToolButton_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QToolButton*>(ptr)->QToolButton::heightForWidth(w);
}

void QToolButton_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "hide");
}

void QToolButton_HideDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::hide();
}

void QToolButton_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QToolButton_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QToolButton_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QToolButton*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QToolButton_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QToolButton*>(ptr)->QToolButton::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QToolButton_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "lower");
}

void QToolButton_LowerDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::lower();
}

void QToolButton_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QToolButton_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

char QToolButton_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QToolButton*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QToolButton_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QToolButton*>(ptr)->QToolButton::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QToolButton_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "raise");
}

void QToolButton_RaiseDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::raise();
}

void QToolButton_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "repaint");
}

void QToolButton_RepaintDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::repaint();
}

void QToolButton_ResizeEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QToolButton_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QToolButton_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QToolButton_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QToolButton*>(ptr)->QToolButton::setDisabled(disable != 0);
}

void QToolButton_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setFocus");
}

void QToolButton_SetFocus2Default(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::setFocus();
}

void QToolButton_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QToolButton_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QToolButton*>(ptr)->QToolButton::setHidden(hidden != 0);
}

void QToolButton_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "show");
}

void QToolButton_ShowDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::show();
}

void QToolButton_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "showFullScreen");
}

void QToolButton_ShowFullScreenDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::showFullScreen();
}

void QToolButton_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "showMaximized");
}

void QToolButton_ShowMaximizedDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::showMaximized();
}

void QToolButton_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "showMinimized");
}

void QToolButton_ShowMinimizedDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::showMinimized();
}

void QToolButton_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "showNormal");
}

void QToolButton_ShowNormalDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::showNormal();
}

void QToolButton_TabletEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QToolButton_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QToolButton_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "update");
}

void QToolButton_UpdateDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::update();
}

void QToolButton_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "updateMicroFocus");
}

void QToolButton_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::updateMicroFocus();
}

void QToolButton_WheelEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QToolButton_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QToolButton_ChildEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QToolButton_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::childEvent(static_cast<QChildEvent*>(event));
}

void QToolButton_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QToolButton*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QToolButton_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QToolButton*>(ptr)->QToolButton::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QToolButton_CustomEvent(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QToolButton_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QToolButton*>(ptr)->QToolButton::customEvent(static_cast<QEvent*>(event));
}

void QToolButton_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "deleteLater");
}

void QToolButton_DeleteLaterDefault(void* ptr)
{
	static_cast<QToolButton*>(ptr)->QToolButton::deleteLater();
}

void QToolButton_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QToolButton*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QToolButton_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QToolButton*>(ptr)->QToolButton::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QToolButton_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QToolButton*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QToolButton_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QToolButton*>(ptr)->QToolButton::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QToolButton_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QToolButton*>(ptr)->metaObject());
}

void* QToolButton_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QToolButton*>(ptr)->QToolButton::metaObject());
}

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_ShowText2(void* pos, char* text, void* w)
{
	QToolTip::showText(*static_cast<QPoint*>(pos), QString(text), static_cast<QWidget*>(w));
}

void QToolTip_QToolTip_ShowText(void* pos, char* text, void* w, void* rect)
{
	QToolTip::showText(*static_cast<QPoint*>(pos), QString(text), static_cast<QWidget*>(w), *static_cast<QRect*>(rect));
}

void QToolTip_QToolTip_ShowText3(void* pos, char* text, void* w, void* rect, int msecDisplayTime)
{
	QToolTip::showText(*static_cast<QPoint*>(pos), QString(text), static_cast<QWidget*>(w), *static_cast<QRect*>(rect), msecDisplayTime);
}

char* QToolTip_QToolTip_Text()
{
	return const_cast<char*>(QToolTip::text().toUtf8().prepend("WHITESPACE").constData()+10);
}

class MyQTreeView: public QTreeView
{
public:
	MyQTreeView(QWidget *parent) : QTreeView(parent) {};
	void collapse(const QModelIndex & index) { callbackQTreeView_Collapse(this, const_cast<QModelIndex*>(&index)); };
	void expand(const QModelIndex & index) { callbackQTreeView_Expand(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 dragMoveEvent(QDragMoveEvent * event) { callbackQTreeView_DragMoveEvent(this, event); };
	void drawBranches(QPainter * painter, const QRect & rect, const QModelIndex & index) const { callbackQTreeView_DrawBranches(const_cast<MyQTreeView*>(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<MyQTreeView*>(this), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	void expandAll() { callbackQTreeView_ExpandAll(this); };
	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<MyQTreeView*>(this)); };
	QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQTreeView_IndexAt(const_cast<MyQTreeView*>(this), const_cast<QPoint*>(&point))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQTreeView_IsIndexHidden(const_cast<MyQTreeView*>(this), const_cast<QModelIndex*>(&index)) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQTreeView_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { callbackQTreeView_KeyboardSearch(this, const_cast<char*>(search.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQTreeView_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQTreeView_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQTreeView_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQTreeView_MouseReleaseEvent(this, event); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQTreeView_MoveCursor(this, cursorAction, modifiers)); };
	void paintEvent(QPaintEvent * event) { callbackQTreeView_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) { callbackQTreeView_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); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQTreeView_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	void setModel(QAbstractItemModel * model) { callbackQTreeView_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) { callbackQTreeView_SetSelectionModel(this, selectionModel); };
	void showColumn(int column) { callbackQTreeView_ShowColumn(this, column); };
	int sizeHintForColumn(int column) const { return callbackQTreeView_SizeHintForColumn(const_cast<MyQTreeView*>(this), column); };
	void updateGeometries() { callbackQTreeView_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQTreeView_VerticalOffset(const_cast<MyQTreeView*>(this)); };
	bool viewportEvent(QEvent * event) { return callbackQTreeView_ViewportEvent(this, event) != 0; };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQTreeView_ViewportSizeHint(const_cast<MyQTreeView*>(this))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQTreeView_VisualRect(const_cast<MyQTreeView*>(this), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQTreeView_VisualRegionForSelection(const_cast<MyQTreeView*>(this), const_cast<QItemSelection*>(&selection))); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQTreeView_DragLeaveEvent(this, event); };
	void clearSelection() { callbackQTreeView_ClearSelection(this); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQTreeView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQTreeView_CommitData(this, editor); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQTreeView_DragEnterEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQTreeView_DropEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQTreeView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQTreeView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQTreeView_EditorDestroyed(this, editor); };
	void focusInEvent(QFocusEvent * event) { callbackQTreeView_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQTreeView_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQTreeView_FocusOutEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQTreeView_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQTreeView_InputMethodQuery(const_cast<MyQTreeView*>(this), query)); };
	void resizeEvent(QResizeEvent * event) { callbackQTreeView_ResizeEvent(this, event); };
	void scrollToBottom() { callbackQTreeView_ScrollToBottom(this); };
	void scrollToTop() { callbackQTreeView_ScrollToTop(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQTreeView_SelectionCommand(const_cast<MyQTreeView*>(this), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQTreeView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	int sizeHintForRow(int row) const { return callbackQTreeView_SizeHintForRow(const_cast<MyQTreeView*>(this), row); };
	void startDrag(Qt::DropActions supportedActions) { callbackQTreeView_StartDrag(this, supportedActions); };
	void update(const QModelIndex & index) { callbackQTreeView_Update(this, const_cast<QModelIndex*>(&index)); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQTreeView_ViewOptions(const_cast<MyQTreeView*>(this))); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQTreeView_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTreeView_MinimumSizeHint(const_cast<MyQTreeView*>(this))); };
	void setupViewport(QWidget * viewport) { callbackQTreeView_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQTreeView_SizeHint(const_cast<MyQTreeView*>(this))); };
	void wheelEvent(QWheelEvent * e) { callbackQTreeView_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQTreeView_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQTreeView_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQTreeView_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQTreeView_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQTreeView_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQTreeView_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQTreeView_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQTreeView_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQTreeView_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQTreeView_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQTreeView_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQTreeView_ShowEvent(this, event); };
	bool close() { return callbackQTreeView_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQTreeView_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQTreeView_HasHeightForWidth(const_cast<MyQTreeView*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQTreeView_HeightForWidth(const_cast<MyQTreeView*>(this), w); };
	void hide() { callbackQTreeView_Hide(this); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQTreeView_KeyReleaseEvent(this, event); };
	void lower() { callbackQTreeView_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTreeView_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQTreeView_Raise(this); };
	void repaint() { callbackQTreeView_Repaint(this); };
	void setDisabled(bool disable) { callbackQTreeView_SetDisabled(this, disable); };
	void setFocus() { callbackQTreeView_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQTreeView_SetHidden(this, hidden); };
	void show() { callbackQTreeView_Show(this); };
	void showFullScreen() { callbackQTreeView_ShowFullScreen(this); };
	void showMaximized() { callbackQTreeView_ShowMaximized(this); };
	void showMinimized() { callbackQTreeView_ShowMinimized(this); };
	void showNormal() { callbackQTreeView_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQTreeView_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQTreeView_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQTreeView_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTreeView_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTreeView_CustomEvent(this, event); };
	void deleteLater() { callbackQTreeView_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTreeView_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTreeView_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTreeView_MetaObject(const_cast<MyQTreeView*>(this))); };
};

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(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTreeView_Expand(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "expand", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

char QTreeView_ExpandsOnDoubleClick(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->expandsOnDoubleClick();
}

int QTreeView_Indentation(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->indentation();
}

char QTreeView_IsAnimated(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->isAnimated();
}

char QTreeView_IsExpanded(void* ptr, void* index)
{
	return static_cast<QTreeView*>(ptr)->isExpanded(*static_cast<QModelIndex*>(index));
}

char QTreeView_IsHeaderHidden(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->isHeaderHidden();
}

char QTreeView_IsSortingEnabled(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->isSortingEnabled();
}

char QTreeView_ItemsExpandable(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->itemsExpandable();
}

void QTreeView_ResetIndentation(void* ptr)
{
	static_cast<QTreeView*>(ptr)->resetIndentation();
}

char QTreeView_RootIsDecorated(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->rootIsDecorated();
}

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_SetExpandsOnDoubleClick(void* ptr, char enable)
{
	static_cast<QTreeView*>(ptr)->setExpandsOnDoubleClick(enable != 0);
}

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_SetRootIsDecorated(void* ptr, char show)
{
	static_cast<QTreeView*>(ptr)->setRootIsDecorated(show != 0);
}

void QTreeView_SetSortingEnabled(void* ptr, char enable)
{
	static_cast<QTreeView*>(ptr)->setSortingEnabled(enable != 0);
}

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);
}

char QTreeView_UniformRowHeights(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->uniformRowHeights();
}

char QTreeView_WordWrap(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->wordWrap();
}

void* QTreeView_NewQTreeView(void* parent)
{
	return new MyQTreeView(static_cast<QWidget*>(parent));
}

void QTreeView_CollapseAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "collapseAll");
}

void QTreeView_ConnectCollapsed(void* ptr)
{
	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));
}

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_ColumnMoved(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "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));
}

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)
{
	static_cast<QTreeView*>(ptr)->QTreeView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QTreeView_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QTreeView_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

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)
{
	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)
{
	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_ExpandAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "expandAll");
}

void QTreeView_ExpandToDepth(void* ptr, int depth)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "expandToDepth", Q_ARG(int, depth));
}

void QTreeView_ConnectExpanded(void* ptr)
{
	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));
}

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));
}

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));
}

int QTreeView_HorizontalOffset(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->horizontalOffset();
}

int QTreeView_HorizontalOffsetDefault(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->QTreeView::horizontalOffset();
}

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)
{
	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_IsColumnHidden(void* ptr, int column)
{
	return static_cast<QTreeView*>(ptr)->isColumnHidden(column);
}

char QTreeView_IsFirstColumnSpanned(void* ptr, int row, void* parent)
{
	return static_cast<QTreeView*>(ptr)->isFirstColumnSpanned(row, *static_cast<QModelIndex*>(parent));
}

char QTreeView_IsIndexHidden(void* ptr, void* index)
{
	return static_cast<QTreeView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}

char QTreeView_IsIndexHiddenDefault(void* ptr, void* index)
{
	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));
}

void QTreeView_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QTreeView_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QTreeView_KeyboardSearch(void* ptr, char* search)
{
	static_cast<QTreeView*>(ptr)->keyboardSearch(QString(search));
}

void QTreeView_KeyboardSearchDefault(void* ptr, char* search)
{
	static_cast<QTreeView*>(ptr)->QTreeView::keyboardSearch(QString(search));
}

void QTreeView_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QTreeView_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QTreeView_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTreeView_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTreeView_MousePressEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTreeView_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTreeView_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QTreeView_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

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)
{
	return new QModelIndex(static_cast<QTreeView*>(ptr)->QTreeView::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void QTreeView_PaintEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QTreeView_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::paintEvent(static_cast<QPaintEvent*>(event));
}

void QTreeView_Reset(void* ptr)
{
	static_cast<QTreeView*>(ptr)->reset();
}

void QTreeView_ResetDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::reset();
}

void QTreeView_ResizeColumnToContents(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "resizeColumnToContents", Q_ARG(int, column));
}

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)
{
	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)
{
	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(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
}

void QTreeView_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QTreeView*>(ptr)->scrollContentsBy(dx, dy);
}

void QTreeView_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QTreeView*>(ptr)->QTreeView::scrollContentsBy(dx, dy);
}

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)
{
	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)
{
	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)
{
	static_cast<QTreeView*>(ptr)->QTreeView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

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_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_SetModel(void* ptr, void* model)
{
	static_cast<QTreeView*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}

void QTreeView_SetModelDefault(void* ptr, void* model)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setModel(static_cast<QAbstractItemModel*>(model));
}

void QTreeView_SetRootIndex(void* ptr, void* index)
{
	static_cast<QTreeView*>(ptr)->setRootIndex(*static_cast<QModelIndex*>(index));
}

void QTreeView_SetRootIndexDefault(void* ptr, void* index)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setRootIndex(*static_cast<QModelIndex*>(index));
}

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)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QTreeView_SetSelectionModel(void* ptr, void* selectionModel)
{
	static_cast<QTreeView*>(ptr)->setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

void QTreeView_SetSelectionModelDefault(void* ptr, void* selectionModel)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

void QTreeView_SetTreePosition(void* ptr, int index)
{
	static_cast<QTreeView*>(ptr)->setTreePosition(index);
}

void QTreeView_ShowColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "showColumn", Q_ARG(int, column));
}

int QTreeView_SizeHintForColumn(void* ptr, int column)
{
	return static_cast<QTreeView*>(ptr)->sizeHintForColumn(column);
}

int QTreeView_SizeHintForColumnDefault(void* ptr, int column)
{
	return static_cast<QTreeView*>(ptr)->QTreeView::sizeHintForColumn(column);
}

void QTreeView_SortByColumn(void* ptr, int column, long long order)
{
	static_cast<QTreeView*>(ptr)->sortByColumn(column, static_cast<Qt::SortOrder>(order));
}

void QTreeView_TimerEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

int QTreeView_TreePosition(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->treePosition();
}

void QTreeView_UpdateGeometries(void* ptr)
{
	static_cast<QTreeView*>(ptr)->updateGeometries();
}

void QTreeView_UpdateGeometriesDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::updateGeometries();
}

int QTreeView_VerticalOffset(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->verticalOffset();
}

int QTreeView_VerticalOffsetDefault(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->QTreeView::verticalOffset();
}

char QTreeView_ViewportEvent(void* ptr, void* event)
{
	return static_cast<QTreeView*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}

char QTreeView_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QTreeView*>(ptr)->QTreeView::viewportEvent(static_cast<QEvent*>(event));
}

void* QTreeView_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTreeView*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTreeView_ViewportSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTreeView*>(ptr)->QTreeView::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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)
{
	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)
{
	return new QRegion(static_cast<QTreeView*>(ptr)->QTreeView::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void QTreeView_DestroyQTreeView(void* ptr)
{
	static_cast<QTreeView*>(ptr)->~QTreeView();
}

void QTreeView_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QTreeView_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QTreeView_ClearSelection(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "clearSelection");
}

void QTreeView_ClearSelectionDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::clearSelection();
}

void QTreeView_CloseEditor(void* ptr, void* editor, long long hint)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "closeEditor", Q_ARG(QWidget*, static_cast<QWidget*>(editor)), Q_ARG(QAbstractItemDelegate::EndEditHint, static_cast<QAbstractItemDelegate::EndEditHint>(hint)));
}

void QTreeView_CloseEditorDefault(void* ptr, void* editor, long long hint)
{
	static_cast<QTreeView*>(ptr)->QTreeView::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
}

void QTreeView_CommitData(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "commitData", Q_ARG(QWidget*, static_cast<QWidget*>(editor)));
}

void QTreeView_CommitDataDefault(void* ptr, void* editor)
{
	static_cast<QTreeView*>(ptr)->QTreeView::commitData(static_cast<QWidget*>(editor));
}

void QTreeView_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTreeView_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTreeView_DropEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QTreeView_DropEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::dropEvent(static_cast<QDropEvent*>(event));
}

void QTreeView_Edit(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "edit", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTreeView_EditDefault(void* ptr, void* index)
{
	static_cast<QTreeView*>(ptr)->QTreeView::edit(*static_cast<QModelIndex*>(index));
}

char QTreeView_Edit2(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QTreeView*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

char QTreeView_Edit2Default(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QTreeView*>(ptr)->QTreeView::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

void QTreeView_EditorDestroyed(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "editorDestroyed", Q_ARG(QObject*, static_cast<QObject*>(editor)));
}

void QTreeView_EditorDestroyedDefault(void* ptr, void* editor)
{
	static_cast<QTreeView*>(ptr)->QTreeView::editorDestroyed(static_cast<QObject*>(editor));
}

void QTreeView_FocusInEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QTreeView_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QTreeView_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QTreeView*>(ptr)->focusNextPrevChild(next != 0);
}

char QTreeView_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QTreeView*>(ptr)->QTreeView::focusNextPrevChild(next != 0);
}

void QTreeView_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTreeView_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTreeView_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QTreeView_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QTreeView_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QTreeView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QTreeView_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QTreeView*>(ptr)->QTreeView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QTreeView_ResizeEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QTreeView_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QTreeView_ScrollToBottom(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "scrollToBottom");
}

void QTreeView_ScrollToBottomDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::scrollToBottom();
}

void QTreeView_ScrollToTop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "scrollToTop");
}

void QTreeView_ScrollToTopDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::scrollToTop();
}

long long QTreeView_SelectionCommand(void* ptr, void* index, void* event)
{
	return static_cast<QTreeView*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

long long QTreeView_SelectionCommandDefault(void* ptr, void* index, void* event)
{
	return static_cast<QTreeView*>(ptr)->QTreeView::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

void QTreeView_SetCurrentIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setCurrentIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTreeView_SetCurrentIndexDefault(void* ptr, void* index)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setCurrentIndex(*static_cast<QModelIndex*>(index));
}

int QTreeView_SizeHintForRow(void* ptr, int row)
{
	return static_cast<QTreeView*>(ptr)->sizeHintForRow(row);
}

int QTreeView_SizeHintForRowDefault(void* ptr, int row)
{
	return static_cast<QTreeView*>(ptr)->QTreeView::sizeHintForRow(row);
}

void QTreeView_StartDrag(void* ptr, long long supportedActions)
{
	static_cast<QTreeView*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QTreeView_StartDragDefault(void* ptr, long long supportedActions)
{
	static_cast<QTreeView*>(ptr)->QTreeView::startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QTreeView_Update(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "update", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTreeView_UpdateDefault(void* ptr, void* index)
{
	static_cast<QTreeView*>(ptr)->QTreeView::update(*static_cast<QModelIndex*>(index));
}

void* QTreeView_ViewOptions(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QTreeView*>(ptr)->viewOptions());
}

void* QTreeView_ViewOptionsDefault(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QTreeView*>(ptr)->QTreeView::viewOptions());
}

void QTreeView_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QTreeView*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QTreeView_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QTreeView*>(ptr)->QTreeView::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void* QTreeView_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTreeView*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTreeView_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTreeView*>(ptr)->QTreeView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTreeView_SetupViewport(void* ptr, void* viewport)
{
	static_cast<QTreeView*>(ptr)->setupViewport(static_cast<QWidget*>(viewport));
}

void QTreeView_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setupViewport(static_cast<QWidget*>(viewport));
}

void* QTreeView_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTreeView*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTreeView_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTreeView*>(ptr)->QTreeView::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTreeView_WheelEvent(void* ptr, void* e)
{
	static_cast<QTreeView*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QTreeView_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QTreeView*>(ptr)->QTreeView::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QTreeView_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QTreeView*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QTreeView_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QTreeView*>(ptr)->QTreeView::changeEvent(static_cast<QEvent*>(ev));
}

void QTreeView_ActionEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QTreeView_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::actionEvent(static_cast<QActionEvent*>(event));
}

void QTreeView_EnterEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QTreeView_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::enterEvent(static_cast<QEvent*>(event));
}

void QTreeView_HideEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QTreeView_HideEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::hideEvent(static_cast<QHideEvent*>(event));
}

void QTreeView_LeaveEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QTreeView_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::leaveEvent(static_cast<QEvent*>(event));
}

void QTreeView_MoveEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QTreeView_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::moveEvent(static_cast<QMoveEvent*>(event));
}

void QTreeView_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QTreeView_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setEnabled(vbo != 0);
}

void QTreeView_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QTreeView_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setStyleSheet(QString(styleSheet));
}

void QTreeView_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QTreeView_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setVisible(visible != 0);
}

void QTreeView_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QTreeView_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setWindowModified(vbo != 0);
}

void QTreeView_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QTreeView_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setWindowTitle(QString(vqs));
}

void QTreeView_ShowEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QTreeView_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::showEvent(static_cast<QShowEvent*>(event));
}

char QTreeView_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QTreeView_CloseDefault(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->QTreeView::close();
}

void QTreeView_CloseEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QTreeView_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::closeEvent(static_cast<QCloseEvent*>(event));
}

char QTreeView_HasHeightForWidth(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->hasHeightForWidth();
}

char QTreeView_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QTreeView*>(ptr)->QTreeView::hasHeightForWidth();
}

int QTreeView_HeightForWidth(void* ptr, int w)
{
	return static_cast<QTreeView*>(ptr)->heightForWidth(w);
}

int QTreeView_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QTreeView*>(ptr)->QTreeView::heightForWidth(w);
}

void QTreeView_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "hide");
}

void QTreeView_HideDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::hide();
}

void QTreeView_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QTreeView_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QTreeView_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "lower");
}

void QTreeView_LowerDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::lower();
}

char QTreeView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTreeView*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QTreeView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTreeView*>(ptr)->QTreeView::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QTreeView_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "raise");
}

void QTreeView_RaiseDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::raise();
}

void QTreeView_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "repaint");
}

void QTreeView_RepaintDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::repaint();
}

void QTreeView_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QTreeView_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setDisabled(disable != 0);
}

void QTreeView_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setFocus");
}

void QTreeView_SetFocus2Default(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setFocus();
}

void QTreeView_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QTreeView_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QTreeView*>(ptr)->QTreeView::setHidden(hidden != 0);
}

void QTreeView_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "show");
}

void QTreeView_ShowDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::show();
}

void QTreeView_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "showFullScreen");
}

void QTreeView_ShowFullScreenDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::showFullScreen();
}

void QTreeView_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "showMaximized");
}

void QTreeView_ShowMaximizedDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::showMaximized();
}

void QTreeView_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "showMinimized");
}

void QTreeView_ShowMinimizedDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::showMinimized();
}

void QTreeView_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "showNormal");
}

void QTreeView_ShowNormalDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::showNormal();
}

void QTreeView_TabletEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTreeView_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTreeView_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "updateMicroFocus");
}

void QTreeView_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::updateMicroFocus();
}

void QTreeView_ChildEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QTreeView_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::childEvent(static_cast<QChildEvent*>(event));
}

void QTreeView_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QTreeView*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTreeView_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTreeView*>(ptr)->QTreeView::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTreeView_CustomEvent(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QTreeView_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QTreeView*>(ptr)->QTreeView::customEvent(static_cast<QEvent*>(event));
}

void QTreeView_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "deleteLater");
}

void QTreeView_DeleteLaterDefault(void* ptr)
{
	static_cast<QTreeView*>(ptr)->QTreeView::deleteLater();
}

void QTreeView_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QTreeView*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTreeView_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTreeView*>(ptr)->QTreeView::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QTreeView_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QTreeView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QTreeView_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QTreeView*>(ptr)->QTreeView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QTreeView_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTreeView*>(ptr)->metaObject());
}

void* QTreeView_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTreeView*>(ptr)->QTreeView::metaObject());
}

class MyQTreeWidget: public QTreeWidget
{
public:
	MyQTreeWidget(QWidget *parent) : QTreeWidget(parent) {};
	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) { callbackQTreeWidget_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; };
	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); };
	QStringList mimeTypes() const { return QString(callbackQTreeWidget_MimeTypes(const_cast<MyQTreeWidget*>(this))).split("|", QString::SkipEmptyParts); };
	void scrollToItem(const QTreeWidgetItem * item, QAbstractItemView::ScrollHint hint) { callbackQTreeWidget_ScrollToItem(this, const_cast<QTreeWidgetItem*>(item), hint); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQTreeWidget_SetSelectionModel(this, selectionModel); };
	Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQTreeWidget_SupportedDropActions(const_cast<MyQTreeWidget*>(this))); };
	void collapse(const QModelIndex & index) { callbackQTreeWidget_Collapse(this, const_cast<QModelIndex*>(&index)); };
	void expand(const QModelIndex & index) { callbackQTreeWidget_Expand(this, const_cast<QModelIndex*>(&index)); };
	void collapseAll() { callbackQTreeWidget_CollapseAll(this); };
	void columnCountChanged(int oldCount, int newCount) { callbackQTreeWidget_ColumnCountChanged(this, oldCount, newCount); };
	void columnMoved() { callbackQTreeWidget_ColumnMoved(this); };
	void columnResized(int column, int oldSize, int newSize) { callbackQTreeWidget_ColumnResized(this, column, oldSize, newSize); };
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQTreeWidget_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQTreeWidget_DragMoveEvent(this, event); };
	void drawBranches(QPainter * painter, const QRect & rect, const QModelIndex & index) const { callbackQTreeWidget_DrawBranches(const_cast<MyQTreeWidget*>(this), painter, const_cast<QRect*>(&rect), const_cast<QModelIndex*>(&index)); };
	void drawRow(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQTreeWidget_DrawRow(const_cast<MyQTreeWidget*>(this), painter, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)); };
	void expandAll() { callbackQTreeWidget_ExpandAll(this); };
	void expandToDepth(int depth) { callbackQTreeWidget_ExpandToDepth(this, depth); };
	void hideColumn(int column) { callbackQTreeWidget_HideColumn(this, column); };
	int horizontalOffset() const { return callbackQTreeWidget_HorizontalOffset(const_cast<MyQTreeWidget*>(this)); };
	QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQTreeWidget_IndexAt(const_cast<MyQTreeWidget*>(this), const_cast<QPoint*>(&point))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQTreeWidget_IsIndexHidden(const_cast<MyQTreeWidget*>(this), const_cast<QModelIndex*>(&index)) != 0; };
	void keyPressEvent(QKeyEvent * event) { callbackQTreeWidget_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { callbackQTreeWidget_KeyboardSearch(this, const_cast<char*>(search.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQTreeWidget_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQTreeWidget_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQTreeWidget_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQTreeWidget_MouseReleaseEvent(this, event); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQTreeWidget_MoveCursor(this, cursorAction, modifiers)); };
	void paintEvent(QPaintEvent * event) { callbackQTreeWidget_PaintEvent(this, event); };
	void reset() { callbackQTreeWidget_Reset(this); };
	void resizeColumnToContents(int column) { callbackQTreeWidget_ResizeColumnToContents(this, column); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQTreeWidget_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQTreeWidget_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsRemoved(const QModelIndex & parent, int start, int end) { callbackQTreeWidget_RowsRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollContentsBy(int dx, int dy) { callbackQTreeWidget_ScrollContentsBy(this, dx, dy); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQTreeWidget_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	void selectAll() { callbackQTreeWidget_SelectAll(this); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQTreeWidget_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	void setModel(QAbstractItemModel * model) { callbackQTreeWidget_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQTreeWidget_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQTreeWidget_SetSelection(this, const_cast<QRect*>(&rect), command); };
	void showColumn(int column) { callbackQTreeWidget_ShowColumn(this, column); };
	int sizeHintForColumn(int column) const { return callbackQTreeWidget_SizeHintForColumn(const_cast<MyQTreeWidget*>(this), column); };
	void updateGeometries() { callbackQTreeWidget_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQTreeWidget_VerticalOffset(const_cast<MyQTreeWidget*>(this)); };
	bool viewportEvent(QEvent * event) { return callbackQTreeWidget_ViewportEvent(this, event) != 0; };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQTreeWidget_ViewportSizeHint(const_cast<MyQTreeWidget*>(this))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQTreeWidget_VisualRect(const_cast<MyQTreeWidget*>(this), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQTreeWidget_VisualRegionForSelection(const_cast<MyQTreeWidget*>(this), const_cast<QItemSelection*>(&selection))); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQTreeWidget_DragLeaveEvent(this, event); };
	void clearSelection() { callbackQTreeWidget_ClearSelection(this); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQTreeWidget_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQTreeWidget_CommitData(this, editor); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQTreeWidget_DragEnterEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQTreeWidget_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQTreeWidget_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQTreeWidget_EditorDestroyed(this, editor); };
	void focusInEvent(QFocusEvent * event) { callbackQTreeWidget_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQTreeWidget_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQTreeWidget_FocusOutEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQTreeWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQTreeWidget_InputMethodQuery(const_cast<MyQTreeWidget*>(this), query)); };
	void resizeEvent(QResizeEvent * event) { callbackQTreeWidget_ResizeEvent(this, event); };
	void scrollToBottom() { callbackQTreeWidget_ScrollToBottom(this); };
	void scrollToTop() { callbackQTreeWidget_ScrollToTop(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQTreeWidget_SelectionCommand(const_cast<MyQTreeWidget*>(this), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQTreeWidget_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	int sizeHintForRow(int row) const { return callbackQTreeWidget_SizeHintForRow(const_cast<MyQTreeWidget*>(this), row); };
	void startDrag(Qt::DropActions supportedActions) { callbackQTreeWidget_StartDrag(this, supportedActions); };
	void update(const QModelIndex & index) { callbackQTreeWidget_Update(this, const_cast<QModelIndex*>(&index)); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQTreeWidget_ViewOptions(const_cast<MyQTreeWidget*>(this))); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQTreeWidget_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTreeWidget_MinimumSizeHint(const_cast<MyQTreeWidget*>(this))); };
	void setupViewport(QWidget * viewport) { callbackQTreeWidget_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQTreeWidget_SizeHint(const_cast<MyQTreeWidget*>(this))); };
	void wheelEvent(QWheelEvent * e) { callbackQTreeWidget_WheelEvent(this, e); };
	void changeEvent(QEvent * ev) { callbackQTreeWidget_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQTreeWidget_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQTreeWidget_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQTreeWidget_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQTreeWidget_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQTreeWidget_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQTreeWidget_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQTreeWidget_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQTreeWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQTreeWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQTreeWidget_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQTreeWidget_ShowEvent(this, event); };
	bool close() { return callbackQTreeWidget_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQTreeWidget_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQTreeWidget_HasHeightForWidth(const_cast<MyQTreeWidget*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQTreeWidget_HeightForWidth(const_cast<MyQTreeWidget*>(this), w); };
	void hide() { callbackQTreeWidget_Hide(this); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQTreeWidget_KeyReleaseEvent(this, event); };
	void lower() { callbackQTreeWidget_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTreeWidget_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQTreeWidget_Raise(this); };
	void repaint() { callbackQTreeWidget_Repaint(this); };
	void setDisabled(bool disable) { callbackQTreeWidget_SetDisabled(this, disable); };
	void setFocus() { callbackQTreeWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQTreeWidget_SetHidden(this, hidden); };
	void show() { callbackQTreeWidget_Show(this); };
	void showFullScreen() { callbackQTreeWidget_ShowFullScreen(this); };
	void showMaximized() { callbackQTreeWidget_ShowMaximized(this); };
	void showMinimized() { callbackQTreeWidget_ShowMinimized(this); };
	void showNormal() { callbackQTreeWidget_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQTreeWidget_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQTreeWidget_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQTreeWidget_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTreeWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTreeWidget_CustomEvent(this, event); };
	void deleteLater() { callbackQTreeWidget_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTreeWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTreeWidget_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTreeWidget_MetaObject(const_cast<MyQTreeWidget*>(this))); };
};

int QTreeWidget_ColumnCount(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->columnCount();
}

void QTreeWidget_SetColumnCount(void* ptr, int columns)
{
	static_cast<QTreeWidget*>(ptr)->setColumnCount(columns);
}

int QTreeWidget_TopLevelItemCount(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->topLevelItemCount();
}

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_Clear(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "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(QTreeWidgetItem*, static_cast<QTreeWidgetItem*>(item)));
}

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)
{
	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));
}

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));
}

void QTreeWidget_DropEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QTreeWidget_DropEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::dropEvent(static_cast<QDropEvent*>(event));
}

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);
}

char QTreeWidget_Event(void* ptr, void* e)
{
	return static_cast<QTreeWidget*>(ptr)->event(static_cast<QEvent*>(e));
}

void QTreeWidget_ExpandItem(void* ptr, void* item)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "expandItem", Q_ARG(QTreeWidgetItem*, static_cast<QTreeWidgetItem*>(item)));
}

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_InvisibleRootItem(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->invisibleRootItem();
}

char QTreeWidget_IsFirstItemColumnSpanned(void* ptr, void* item)
{
	return static_cast<QTreeWidget*>(ptr)->isFirstItemColumnSpanned(static_cast<QTreeWidgetItem*>(item));
}

void* QTreeWidget_ItemAbove(void* ptr, void* item)
{
	return static_cast<QTreeWidget*>(ptr)->itemAbove(static_cast<QTreeWidgetItem*>(item));
}

void QTreeWidget_ConnectItemActivated(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	QObject::connect(static_cast<QTreeWidget*>(ptr), static_cast<void (QTreeWidget::*)()>(&QTreeWidget::itemSelectionChanged), static_cast<MyQTreeWidget*>(ptr), static_cast<void (MyQTreeWidget::*)()>(&MyQTreeWidget::Signal_ItemSelectionChanged));
}

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);
}

char* QTreeWidget_MimeTypes(void* ptr)
{
	return const_cast<char*>(static_cast<QTreeWidget*>(ptr)->mimeTypes().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QTreeWidget_MimeTypesDefault(void* ptr)
{
	return const_cast<char*>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::mimeTypes().join("|").toUtf8().prepend("WHITESPACE").constData()+10);
}

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)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "scrollToItem", Q_ARG(QTreeWidgetItem*, static_cast<QTreeWidgetItem*>(item)), Q_ARG(QAbstractItemView::ScrollHint, static_cast<QAbstractItemView::ScrollHint>(hint)));
}

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_SetFirstItemColumnSpanned(void* ptr, void* item, char span)
{
	static_cast<QTreeWidget*>(ptr)->setFirstItemColumnSpanned(static_cast<QTreeWidgetItem*>(item), span != 0);
}

void QTreeWidget_SetHeaderItem(void* ptr, void* item)
{
	static_cast<QTreeWidget*>(ptr)->setHeaderItem(static_cast<QTreeWidgetItem*>(item));
}

void QTreeWidget_SetHeaderLabel(void* ptr, char* label)
{
	static_cast<QTreeWidget*>(ptr)->setHeaderLabel(QString(label));
}

void QTreeWidget_SetHeaderLabels(void* ptr, char* labels)
{
	static_cast<QTreeWidget*>(ptr)->setHeaderLabels(QString(labels).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));
}

void QTreeWidget_SetSelectionModel(void* ptr, void* selectionModel)
{
	static_cast<QTreeWidget*>(ptr)->setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

void QTreeWidget_SetSelectionModelDefault(void* ptr, void* selectionModel)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

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);
}

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_Collapse(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "collapse", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTreeWidget_CollapseDefault(void* ptr, void* index)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::collapse(*static_cast<QModelIndex*>(index));
}

void QTreeWidget_Expand(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "expand", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTreeWidget_ExpandDefault(void* ptr, void* index)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::expand(*static_cast<QModelIndex*>(index));
}

void QTreeWidget_CollapseAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "collapseAll");
}

void QTreeWidget_CollapseAllDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::collapseAll();
}

void QTreeWidget_ColumnCountChanged(void* ptr, int oldCount, int newCount)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "columnCountChanged", Q_ARG(int, oldCount), Q_ARG(int, newCount));
}

void QTreeWidget_ColumnCountChangedDefault(void* ptr, int oldCount, int newCount)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::columnCountChanged(oldCount, newCount);
}

void QTreeWidget_ColumnMoved(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "columnMoved");
}

void QTreeWidget_ColumnMovedDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::columnMoved();
}

void QTreeWidget_ColumnResized(void* ptr, int column, int oldSize, int newSize)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "columnResized", Q_ARG(int, column), Q_ARG(int, oldSize), Q_ARG(int, newSize));
}

void QTreeWidget_ColumnResizedDefault(void* ptr, int column, int oldSize, int newSize)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::columnResized(column, oldSize, newSize);
}

void QTreeWidget_CurrentChanged(void* ptr, void* current, void* previous)
{
	static_cast<QTreeWidget*>(ptr)->currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QTreeWidget_CurrentChangedDefault(void* ptr, void* current, void* previous)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QTreeWidget_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QTreeWidget_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QTreeWidget_DrawBranches(void* ptr, void* painter, void* rect, void* index)
{
	static_cast<QTreeWidget*>(ptr)->drawBranches(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), *static_cast<QModelIndex*>(index));
}

void QTreeWidget_DrawBranchesDefault(void* ptr, void* painter, void* rect, void* index)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::drawBranches(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), *static_cast<QModelIndex*>(index));
}

void QTreeWidget_DrawRow(void* ptr, void* painter, void* option, void* index)
{
	static_cast<QTreeWidget*>(ptr)->drawRow(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QTreeWidget_DrawRowDefault(void* ptr, void* painter, void* option, void* index)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::drawRow(static_cast<QPainter*>(painter), *static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index));
}

void QTreeWidget_ExpandAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "expandAll");
}

void QTreeWidget_ExpandAllDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::expandAll();
}

void QTreeWidget_ExpandToDepth(void* ptr, int depth)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "expandToDepth", Q_ARG(int, depth));
}

void QTreeWidget_ExpandToDepthDefault(void* ptr, int depth)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::expandToDepth(depth);
}

void QTreeWidget_HideColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "hideColumn", Q_ARG(int, column));
}

void QTreeWidget_HideColumnDefault(void* ptr, int column)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::hideColumn(column);
}

int QTreeWidget_HorizontalOffset(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->horizontalOffset();
}

int QTreeWidget_HorizontalOffsetDefault(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::horizontalOffset();
}

void* QTreeWidget_IndexAt(void* ptr, void* point)
{
	return new QModelIndex(static_cast<QTreeWidget*>(ptr)->indexAt(*static_cast<QPoint*>(point)));
}

void* QTreeWidget_IndexAtDefault(void* ptr, void* point)
{
	return new QModelIndex(static_cast<QTreeWidget*>(ptr)->QTreeWidget::indexAt(*static_cast<QPoint*>(point)));
}

char QTreeWidget_IsIndexHidden(void* ptr, void* index)
{
	return static_cast<QTreeWidget*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}

char QTreeWidget_IsIndexHiddenDefault(void* ptr, void* index)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::isIndexHidden(*static_cast<QModelIndex*>(index));
}

void QTreeWidget_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QTreeWidget_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QTreeWidget_KeyboardSearch(void* ptr, char* search)
{
	static_cast<QTreeWidget*>(ptr)->keyboardSearch(QString(search));
}

void QTreeWidget_KeyboardSearchDefault(void* ptr, char* search)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::keyboardSearch(QString(search));
}

void QTreeWidget_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QTreeWidget_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QTreeWidget_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTreeWidget_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QTreeWidget_MousePressEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTreeWidget_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QTreeWidget_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QTreeWidget_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void* QTreeWidget_MoveCursor(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QTreeWidget*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void* QTreeWidget_MoveCursorDefault(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QTreeWidget*>(ptr)->QTreeWidget::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void QTreeWidget_PaintEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QTreeWidget_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::paintEvent(static_cast<QPaintEvent*>(event));
}

void QTreeWidget_Reset(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->reset();
}

void QTreeWidget_ResetDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::reset();
}

void QTreeWidget_ResizeColumnToContents(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "resizeColumnToContents", Q_ARG(int, column));
}

void QTreeWidget_ResizeColumnToContentsDefault(void* ptr, int column)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::resizeColumnToContents(column);
}

void QTreeWidget_RowsAboutToBeRemoved(void* ptr, void* parent, int start, int end)
{
	static_cast<QTreeWidget*>(ptr)->rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
}

void QTreeWidget_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
}

void QTreeWidget_RowsInserted(void* ptr, void* parent, int start, int end)
{
	static_cast<QTreeWidget*>(ptr)->rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
}

void QTreeWidget_RowsInsertedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
}

void QTreeWidget_RowsRemoved(void* ptr, void* parent, int start, int end)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "rowsRemoved", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(parent)), Q_ARG(int, start), Q_ARG(int, end));
}

void QTreeWidget_RowsRemovedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::rowsRemoved(*static_cast<QModelIndex*>(parent), start, end);
}

void QTreeWidget_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QTreeWidget*>(ptr)->scrollContentsBy(dx, dy);
}

void QTreeWidget_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::scrollContentsBy(dx, dy);
}

void QTreeWidget_ScrollTo(void* ptr, void* index, long long hint)
{
	static_cast<QTreeWidget*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QTreeWidget_ScrollToDefault(void* ptr, void* index, long long hint)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QTreeWidget_SelectAll(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->selectAll();
}

void QTreeWidget_SelectAllDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::selectAll();
}

void QTreeWidget_SelectionChanged(void* ptr, void* selected, void* deselected)
{
	static_cast<QTreeWidget*>(ptr)->selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

void QTreeWidget_SelectionChangedDefault(void* ptr, void* selected, void* deselected)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

void QTreeWidget_SetModel(void* ptr, void* model)
{
	static_cast<QTreeWidget*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}

void QTreeWidget_SetModelDefault(void* ptr, void* model)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setModel(static_cast<QAbstractItemModel*>(model));
}

void QTreeWidget_SetRootIndex(void* ptr, void* index)
{
	static_cast<QTreeWidget*>(ptr)->setRootIndex(*static_cast<QModelIndex*>(index));
}

void QTreeWidget_SetRootIndexDefault(void* ptr, void* index)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setRootIndex(*static_cast<QModelIndex*>(index));
}

void QTreeWidget_SetSelection(void* ptr, void* rect, long long command)
{
	static_cast<QTreeWidget*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QTreeWidget_SetSelectionDefault(void* ptr, void* rect, long long command)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QTreeWidget_ShowColumn(void* ptr, int column)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "showColumn", Q_ARG(int, column));
}

void QTreeWidget_ShowColumnDefault(void* ptr, int column)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::showColumn(column);
}

int QTreeWidget_SizeHintForColumn(void* ptr, int column)
{
	return static_cast<QTreeWidget*>(ptr)->sizeHintForColumn(column);
}

int QTreeWidget_SizeHintForColumnDefault(void* ptr, int column)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::sizeHintForColumn(column);
}

void QTreeWidget_UpdateGeometries(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->updateGeometries();
}

void QTreeWidget_UpdateGeometriesDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::updateGeometries();
}

int QTreeWidget_VerticalOffset(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->verticalOffset();
}

int QTreeWidget_VerticalOffsetDefault(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::verticalOffset();
}

char QTreeWidget_ViewportEvent(void* ptr, void* event)
{
	return static_cast<QTreeWidget*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}

char QTreeWidget_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::viewportEvent(static_cast<QEvent*>(event));
}

void* QTreeWidget_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTreeWidget*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTreeWidget_ViewportSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTreeWidget*>(ptr)->QTreeWidget::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTreeWidget_VisualRect(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QTreeWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QTreeWidget_VisualRectDefault(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QTreeWidget*>(ptr)->QTreeWidget::visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QTreeWidget_VisualRegionForSelection(void* ptr, void* selection)
{
	return new QRegion(static_cast<QTreeWidget*>(ptr)->visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void* QTreeWidget_VisualRegionForSelectionDefault(void* ptr, void* selection)
{
	return new QRegion(static_cast<QTreeWidget*>(ptr)->QTreeWidget::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void QTreeWidget_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QTreeWidget_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QTreeWidget_ClearSelection(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "clearSelection");
}

void QTreeWidget_ClearSelectionDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::clearSelection();
}

void QTreeWidget_CloseEditor(void* ptr, void* editor, long long hint)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "closeEditor", Q_ARG(QWidget*, static_cast<QWidget*>(editor)), Q_ARG(QAbstractItemDelegate::EndEditHint, static_cast<QAbstractItemDelegate::EndEditHint>(hint)));
}

void QTreeWidget_CloseEditorDefault(void* ptr, void* editor, long long hint)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
}

void QTreeWidget_CommitData(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "commitData", Q_ARG(QWidget*, static_cast<QWidget*>(editor)));
}

void QTreeWidget_CommitDataDefault(void* ptr, void* editor)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::commitData(static_cast<QWidget*>(editor));
}

void QTreeWidget_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTreeWidget_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QTreeWidget_Edit(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "edit", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTreeWidget_EditDefault(void* ptr, void* index)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::edit(*static_cast<QModelIndex*>(index));
}

char QTreeWidget_Edit2(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QTreeWidget*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

char QTreeWidget_Edit2Default(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

void QTreeWidget_EditorDestroyed(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "editorDestroyed", Q_ARG(QObject*, static_cast<QObject*>(editor)));
}

void QTreeWidget_EditorDestroyedDefault(void* ptr, void* editor)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::editorDestroyed(static_cast<QObject*>(editor));
}

void QTreeWidget_FocusInEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QTreeWidget_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QTreeWidget_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QTreeWidget*>(ptr)->focusNextPrevChild(next != 0);
}

char QTreeWidget_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::focusNextPrevChild(next != 0);
}

void QTreeWidget_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTreeWidget_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QTreeWidget_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QTreeWidget_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QTreeWidget_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QTreeWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QTreeWidget_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QTreeWidget*>(ptr)->QTreeWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QTreeWidget_ResizeEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QTreeWidget_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QTreeWidget_ScrollToBottom(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "scrollToBottom");
}

void QTreeWidget_ScrollToBottomDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::scrollToBottom();
}

void QTreeWidget_ScrollToTop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "scrollToTop");
}

void QTreeWidget_ScrollToTopDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::scrollToTop();
}

long long QTreeWidget_SelectionCommand(void* ptr, void* index, void* event)
{
	return static_cast<QTreeWidget*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

long long QTreeWidget_SelectionCommandDefault(void* ptr, void* index, void* event)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

void QTreeWidget_SetCurrentIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setCurrentIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTreeWidget_SetCurrentIndexDefault(void* ptr, void* index)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setCurrentIndex(*static_cast<QModelIndex*>(index));
}

int QTreeWidget_SizeHintForRow(void* ptr, int row)
{
	return static_cast<QTreeWidget*>(ptr)->sizeHintForRow(row);
}

int QTreeWidget_SizeHintForRowDefault(void* ptr, int row)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::sizeHintForRow(row);
}

void QTreeWidget_StartDrag(void* ptr, long long supportedActions)
{
	static_cast<QTreeWidget*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QTreeWidget_StartDragDefault(void* ptr, long long supportedActions)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QTreeWidget_Update(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "update", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QTreeWidget_UpdateDefault(void* ptr, void* index)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::update(*static_cast<QModelIndex*>(index));
}

void* QTreeWidget_ViewOptions(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QTreeWidget*>(ptr)->viewOptions());
}

void* QTreeWidget_ViewOptionsDefault(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QTreeWidget*>(ptr)->QTreeWidget::viewOptions());
}

void QTreeWidget_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QTreeWidget*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QTreeWidget_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void* QTreeWidget_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTreeWidget*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTreeWidget_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTreeWidget*>(ptr)->QTreeWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTreeWidget_SetupViewport(void* ptr, void* viewport)
{
	static_cast<QTreeWidget*>(ptr)->setupViewport(static_cast<QWidget*>(viewport));
}

void QTreeWidget_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setupViewport(static_cast<QWidget*>(viewport));
}

void* QTreeWidget_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTreeWidget*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QTreeWidget_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QTreeWidget*>(ptr)->QTreeWidget::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QTreeWidget_WheelEvent(void* ptr, void* e)
{
	static_cast<QTreeWidget*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QTreeWidget_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::wheelEvent(static_cast<QWheelEvent*>(e));
}

void QTreeWidget_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QTreeWidget*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QTreeWidget_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::changeEvent(static_cast<QEvent*>(ev));
}

void QTreeWidget_ActionEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QTreeWidget_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::actionEvent(static_cast<QActionEvent*>(event));
}

void QTreeWidget_EnterEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QTreeWidget_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::enterEvent(static_cast<QEvent*>(event));
}

void QTreeWidget_HideEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QTreeWidget_HideEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::hideEvent(static_cast<QHideEvent*>(event));
}

void QTreeWidget_LeaveEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QTreeWidget_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::leaveEvent(static_cast<QEvent*>(event));
}

void QTreeWidget_MoveEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QTreeWidget_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::moveEvent(static_cast<QMoveEvent*>(event));
}

void QTreeWidget_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QTreeWidget_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setEnabled(vbo != 0);
}

void QTreeWidget_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QTreeWidget_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setStyleSheet(QString(styleSheet));
}

void QTreeWidget_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QTreeWidget_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setVisible(visible != 0);
}

void QTreeWidget_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QTreeWidget_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setWindowModified(vbo != 0);
}

void QTreeWidget_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QTreeWidget_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setWindowTitle(QString(vqs));
}

void QTreeWidget_ShowEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QTreeWidget_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::showEvent(static_cast<QShowEvent*>(event));
}

char QTreeWidget_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QTreeWidget_CloseDefault(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::close();
}

void QTreeWidget_CloseEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QTreeWidget_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::closeEvent(static_cast<QCloseEvent*>(event));
}

char QTreeWidget_HasHeightForWidth(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->hasHeightForWidth();
}

char QTreeWidget_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::hasHeightForWidth();
}

int QTreeWidget_HeightForWidth(void* ptr, int w)
{
	return static_cast<QTreeWidget*>(ptr)->heightForWidth(w);
}

int QTreeWidget_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::heightForWidth(w);
}

void QTreeWidget_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "hide");
}

void QTreeWidget_HideDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::hide();
}

void QTreeWidget_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QTreeWidget_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QTreeWidget_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "lower");
}

void QTreeWidget_LowerDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::lower();
}

char QTreeWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTreeWidget*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QTreeWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QTreeWidget_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "raise");
}

void QTreeWidget_RaiseDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::raise();
}

void QTreeWidget_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "repaint");
}

void QTreeWidget_RepaintDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::repaint();
}

void QTreeWidget_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QTreeWidget_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setDisabled(disable != 0);
}

void QTreeWidget_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setFocus");
}

void QTreeWidget_SetFocus2Default(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setFocus();
}

void QTreeWidget_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QTreeWidget_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::setHidden(hidden != 0);
}

void QTreeWidget_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "show");
}

void QTreeWidget_ShowDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::show();
}

void QTreeWidget_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "showFullScreen");
}

void QTreeWidget_ShowFullScreenDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::showFullScreen();
}

void QTreeWidget_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "showMaximized");
}

void QTreeWidget_ShowMaximizedDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::showMaximized();
}

void QTreeWidget_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "showMinimized");
}

void QTreeWidget_ShowMinimizedDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::showMinimized();
}

void QTreeWidget_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "showNormal");
}

void QTreeWidget_ShowNormalDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::showNormal();
}

void QTreeWidget_TabletEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTreeWidget_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QTreeWidget_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "updateMicroFocus");
}

void QTreeWidget_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::updateMicroFocus();
}

void QTreeWidget_ChildEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QTreeWidget_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::childEvent(static_cast<QChildEvent*>(event));
}

void QTreeWidget_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QTreeWidget*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTreeWidget_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTreeWidget_CustomEvent(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QTreeWidget_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::customEvent(static_cast<QEvent*>(event));
}

void QTreeWidget_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "deleteLater");
}

void QTreeWidget_DeleteLaterDefault(void* ptr)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::deleteLater();
}

void QTreeWidget_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QTreeWidget*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTreeWidget_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QTreeWidget*>(ptr)->QTreeWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QTreeWidget_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QTreeWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QTreeWidget_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QTreeWidget*>(ptr)->QTreeWidget::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QTreeWidget_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTreeWidget*>(ptr)->metaObject());
}

void* QTreeWidget_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::metaObject());
}

class MyQTreeWidgetItem: public QTreeWidgetItem
{
public:
	MyQTreeWidgetItem(QTreeWidget *parent, QTreeWidgetItem *preceding, int type) : QTreeWidgetItem(parent, preceding, type) {};
	MyQTreeWidgetItem(QTreeWidget *parent, const QStringList &strings, int type) : QTreeWidgetItem(parent, strings, type) {};
	MyQTreeWidgetItem(QTreeWidget *parent, int type) : QTreeWidgetItem(parent, type) {};
	MyQTreeWidgetItem(QTreeWidgetItem *parent, QTreeWidgetItem *preceding, int type) : QTreeWidgetItem(parent, preceding, type) {};
	MyQTreeWidgetItem(QTreeWidgetItem *parent, const QStringList &strings, int type) : QTreeWidgetItem(parent, strings, type) {};
	MyQTreeWidgetItem(QTreeWidgetItem *parent, int type) : QTreeWidgetItem(parent, type) {};
	MyQTreeWidgetItem(const QStringList &strings, int type) : QTreeWidgetItem(strings, type) {};
	MyQTreeWidgetItem(const QTreeWidgetItem &other) : QTreeWidgetItem(other) {};
	MyQTreeWidgetItem(int type) : QTreeWidgetItem(type) {};
	QVariant data(int column, int role) const { return *static_cast<QVariant*>(callbackQTreeWidgetItem_Data(const_cast<MyQTreeWidgetItem*>(this), column, role)); };
	QTreeWidgetItem * clone() const { return static_cast<QTreeWidgetItem*>(callbackQTreeWidgetItem_Clone(const_cast<MyQTreeWidgetItem*>(this))); };
	void setData(int column, int role, const QVariant & value) { callbackQTreeWidgetItem_SetData(this, column, role, const_cast<QVariant*>(&value)); };
	 ~MyQTreeWidgetItem() { callbackQTreeWidgetItem_DestroyQTreeWidgetItem(this); };
};

void* QTreeWidgetItem_NewQTreeWidgetItem5(void* parent, void* preceding, int ty)
{
	return new MyQTreeWidgetItem(static_cast<QTreeWidget*>(parent), static_cast<QTreeWidgetItem*>(preceding), ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem4(void* parent, char* strin, int ty)
{
	return new MyQTreeWidgetItem(static_cast<QTreeWidget*>(parent), QString(strin).split("|", QString::SkipEmptyParts), ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem3(void* parent, int ty)
{
	return new MyQTreeWidgetItem(static_cast<QTreeWidget*>(parent), ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem8(void* parent, void* preceding, int ty)
{
	return new MyQTreeWidgetItem(static_cast<QTreeWidgetItem*>(parent), static_cast<QTreeWidgetItem*>(preceding), ty);
}

long long QTreeWidgetItem_Flags(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->flags();
}

void QTreeWidgetItem_SetFlags(void* ptr, long long flags)
{
	static_cast<QTreeWidgetItem*>(ptr)->setFlags(static_cast<Qt::ItemFlag>(flags));
}

void* QTreeWidgetItem_NewQTreeWidgetItem7(void* parent, char* strin, int ty)
{
	return new MyQTreeWidgetItem(static_cast<QTreeWidgetItem*>(parent), QString(strin).split("|", QString::SkipEmptyParts), ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem6(void* parent, int ty)
{
	return new MyQTreeWidgetItem(static_cast<QTreeWidgetItem*>(parent), ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem2(char* strin, int ty)
{
	return new MyQTreeWidgetItem(QString(strin).split("|", QString::SkipEmptyParts), ty);
}

void* QTreeWidgetItem_NewQTreeWidgetItem9(void* other)
{
	return new MyQTreeWidgetItem(*static_cast<QTreeWidgetItem*>(other));
}

void* QTreeWidgetItem_NewQTreeWidgetItem(int ty)
{
	return new MyQTreeWidgetItem(ty);
}

void QTreeWidgetItem_AddChild(void* ptr, void* child)
{
	static_cast<QTreeWidgetItem*>(ptr)->addChild(static_cast<QTreeWidgetItem*>(child));
}

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();
}

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();
}

void* QTreeWidgetItem_Clone(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->clone();
}

void* QTreeWidgetItem_CloneDefault(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->QTreeWidgetItem::clone();
}

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));
}

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_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_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, char* statusTip)
{
	static_cast<QTreeWidgetItem*>(ptr)->setStatusTip(column, QString(statusTip));
}

void QTreeWidgetItem_SetText(void* ptr, int column, char* text)
{
	static_cast<QTreeWidgetItem*>(ptr)->setText(column, QString(text));
}

void QTreeWidgetItem_SetTextAlignment(void* ptr, int column, int alignment)
{
	static_cast<QTreeWidgetItem*>(ptr)->setTextAlignment(column, alignment);
}

void QTreeWidgetItem_SetToolTip(void* ptr, int column, char* toolTip)
{
	static_cast<QTreeWidgetItem*>(ptr)->setToolTip(column, QString(toolTip));
}

void QTreeWidgetItem_SetWhatsThis(void* ptr, int column, char* whatsThis)
{
	static_cast<QTreeWidgetItem*>(ptr)->setWhatsThis(column, QString(whatsThis));
}

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));
}

char* QTreeWidgetItem_StatusTip(void* ptr, int column)
{
	return const_cast<char*>(static_cast<QTreeWidgetItem*>(ptr)->statusTip(column).toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QTreeWidgetItem_TakeChild(void* ptr, int index)
{
	return static_cast<QTreeWidgetItem*>(ptr)->takeChild(index);
}

char* QTreeWidgetItem_Text(void* ptr, int column)
{
	return const_cast<char*>(static_cast<QTreeWidgetItem*>(ptr)->text(column).toUtf8().prepend("WHITESPACE").constData()+10);
}

int QTreeWidgetItem_TextAlignment(void* ptr, int column)
{
	return static_cast<QTreeWidgetItem*>(ptr)->textAlignment(column);
}

char* QTreeWidgetItem_ToolTip(void* ptr, int column)
{
	return const_cast<char*>(static_cast<QTreeWidgetItem*>(ptr)->toolTip(column).toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QTreeWidgetItem_TreeWidget(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->treeWidget();
}

int QTreeWidgetItem_Type(void* ptr)
{
	return static_cast<QTreeWidgetItem*>(ptr)->type();
}

char* QTreeWidgetItem_WhatsThis(void* ptr, int column)
{
	return const_cast<char*>(static_cast<QTreeWidgetItem*>(ptr)->whatsThis(column).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QTreeWidgetItem_DestroyQTreeWidgetItem(void* ptr)
{
	static_cast<QTreeWidgetItem*>(ptr)->~QTreeWidgetItem();
}

void QTreeWidgetItem_DestroyQTreeWidgetItemDefault(void* ptr)
{

}

class MyQUndoCommand: public QUndoCommand
{
public:
	MyQUndoCommand(QUndoCommand *parent) : QUndoCommand(parent) {};
	MyQUndoCommand(const QString &text, QUndoCommand *parent) : QUndoCommand(text, parent) {};
	int id() const { return callbackQUndoCommand_Id(const_cast<MyQUndoCommand*>(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); };
};

void* QUndoCommand_NewQUndoCommand(void* parent)
{
	return new MyQUndoCommand(static_cast<QUndoCommand*>(parent));
}

void* QUndoCommand_NewQUndoCommand2(char* text, void* parent)
{
	return new MyQUndoCommand(QString(text), static_cast<QUndoCommand*>(parent));
}

char* QUndoCommand_ActionText(void* ptr)
{
	return const_cast<char*>(static_cast<QUndoCommand*>(ptr)->actionText().toUtf8().prepend("WHITESPACE").constData()+10);
}

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_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_SetText(void* ptr, char* text)
{
	static_cast<QUndoCommand*>(ptr)->setText(QString(text));
}

char* QUndoCommand_Text(void* ptr)
{
	return const_cast<char*>(static_cast<QUndoCommand*>(ptr)->text().toUtf8().prepend("WHITESPACE").constData()+10);
}

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)
{

}

class MyQUndoGroup: public QUndoGroup
{
public:
	MyQUndoGroup(QObject *parent) : QUndoGroup(parent) {};
	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) { callbackQUndoGroup_RedoTextChanged(this, const_cast<char*>(redoText.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setActiveStack(QUndoStack * stack) { callbackQUndoGroup_SetActiveStack(this, stack); };
	void undo() { callbackQUndoGroup_Undo(this); };
	void Signal_UndoTextChanged(const QString & undoText) { callbackQUndoGroup_UndoTextChanged(this, const_cast<char*>(undoText.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void timerEvent(QTimerEvent * event) { callbackQUndoGroup_TimerEvent(this, event); };
	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 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<MyQUndoGroup*>(this))); };
};

void* QUndoGroup_NewQUndoGroup(void* parent)
{
	return new MyQUndoGroup(static_cast<QObject*>(parent));
}

void* QUndoGroup_ActiveStack(void* ptr)
{
	return static_cast<QUndoGroup*>(ptr)->activeStack();
}

void QUndoGroup_ConnectActiveStackChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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, char* prefix)
{
	return static_cast<QUndoGroup*>(ptr)->createRedoAction(static_cast<QObject*>(parent), QString(prefix));
}

void* QUndoGroup_CreateUndoAction(void* ptr, void* parent, char* prefix)
{
	return static_cast<QUndoGroup*>(ptr)->createUndoAction(static_cast<QObject*>(parent), QString(prefix));
}

void QUndoGroup_ConnectIndexChanged(void* ptr)
{
	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));
}

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");
}

char* QUndoGroup_RedoText(void* ptr)
{
	return const_cast<char*>(static_cast<QUndoGroup*>(ptr)->redoText().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QUndoGroup_ConnectRedoTextChanged(void* ptr)
{
	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));
}

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, char* redoText)
{
	static_cast<QUndoGroup*>(ptr)->redoTextChanged(QString(redoText));
}

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_Undo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoGroup*>(ptr), "undo");
}

char* QUndoGroup_UndoText(void* ptr)
{
	return const_cast<char*>(static_cast<QUndoGroup*>(ptr)->undoText().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QUndoGroup_ConnectUndoTextChanged(void* ptr)
{
	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));
}

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, char* undoText)
{
	static_cast<QUndoGroup*>(ptr)->undoTextChanged(QString(undoText));
}

void QUndoGroup_DestroyQUndoGroup(void* ptr)
{
	static_cast<QUndoGroup*>(ptr)->~QUndoGroup();
}

void QUndoGroup_TimerEvent(void* ptr, void* event)
{
	static_cast<QUndoGroup*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QUndoGroup_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QUndoGroup*>(ptr)->QUndoGroup::timerEvent(static_cast<QTimerEvent*>(event));
}

void QUndoGroup_ChildEvent(void* ptr, void* event)
{
	static_cast<QUndoGroup*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QUndoGroup_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QUndoGroup*>(ptr)->QUndoGroup::childEvent(static_cast<QChildEvent*>(event));
}

void QUndoGroup_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QUndoGroup*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QUndoGroup_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QUndoGroup*>(ptr)->QUndoGroup::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QUndoGroup_CustomEvent(void* ptr, void* event)
{
	static_cast<QUndoGroup*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QUndoGroup_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QUndoGroup*>(ptr)->QUndoGroup::customEvent(static_cast<QEvent*>(event));
}

void QUndoGroup_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoGroup*>(ptr), "deleteLater");
}

void QUndoGroup_DeleteLaterDefault(void* ptr)
{
	static_cast<QUndoGroup*>(ptr)->QUndoGroup::deleteLater();
}

void QUndoGroup_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QUndoGroup*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QUndoGroup_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QUndoGroup*>(ptr)->QUndoGroup::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QUndoGroup_Event(void* ptr, void* e)
{
	return static_cast<QUndoGroup*>(ptr)->event(static_cast<QEvent*>(e));
}

char QUndoGroup_EventDefault(void* ptr, void* e)
{
	return static_cast<QUndoGroup*>(ptr)->QUndoGroup::event(static_cast<QEvent*>(e));
}

char QUndoGroup_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QUndoGroup*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QUndoGroup_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QUndoGroup*>(ptr)->QUndoGroup::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QUndoGroup_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QUndoGroup*>(ptr)->metaObject());
}

void* QUndoGroup_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QUndoGroup*>(ptr)->QUndoGroup::metaObject());
}

class MyQUndoStack: public QUndoStack
{
public:
	MyQUndoStack(QObject *parent) : QUndoStack(parent) {};
	void setActive(bool active) { callbackQUndoStack_SetActive(this, active); };
	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) { callbackQUndoStack_RedoTextChanged(this, const_cast<char*>(redoText.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setClean() { callbackQUndoStack_SetClean(this); };
	void setIndex(int idx) { callbackQUndoStack_SetIndex(this, idx); };
	void undo() { callbackQUndoStack_Undo(this); };
	void Signal_UndoTextChanged(const QString & undoText) { callbackQUndoStack_UndoTextChanged(this, const_cast<char*>(undoText.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void timerEvent(QTimerEvent * event) { callbackQUndoStack_TimerEvent(this, event); };
	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 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<MyQUndoStack*>(this))); };
};

char QUndoStack_IsActive(void* ptr)
{
	return static_cast<QUndoStack*>(ptr)->isActive();
}

void QUndoStack_SetActive(void* ptr, char active)
{
	QMetaObject::invokeMethod(static_cast<QUndoStack*>(ptr), "setActive", Q_ARG(bool, active != 0));
}

void QUndoStack_SetUndoLimit(void* ptr, int limit)
{
	static_cast<QUndoStack*>(ptr)->setUndoLimit(limit);
}

int QUndoStack_UndoLimit(void* ptr)
{
	return static_cast<QUndoStack*>(ptr)->undoLimit();
}

void* QUndoStack_NewQUndoStack(void* parent)
{
	return new MyQUndoStack(static_cast<QObject*>(parent));
}

void QUndoStack_BeginMacro(void* ptr, char* text)
{
	static_cast<QUndoStack*>(ptr)->beginMacro(QString(text));
}

char QUndoStack_CanRedo(void* ptr)
{
	return static_cast<QUndoStack*>(ptr)->canRedo();
}

void QUndoStack_ConnectCanRedoChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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)
{
	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));
}

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, char* prefix)
{
	return static_cast<QUndoStack*>(ptr)->createRedoAction(static_cast<QObject*>(parent), QString(prefix));
}

void* QUndoStack_CreateUndoAction(void* ptr, void* parent, char* prefix)
{
	return static_cast<QUndoStack*>(ptr)->createUndoAction(static_cast<QObject*>(parent), QString(prefix));
}

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)
{
	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));
}

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_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");
}

char* QUndoStack_RedoText(void* ptr)
{
	return const_cast<char*>(static_cast<QUndoStack*>(ptr)->redoText().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QUndoStack_ConnectRedoTextChanged(void* ptr)
{
	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));
}

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, char* redoText)
{
	static_cast<QUndoStack*>(ptr)->redoTextChanged(QString(redoText));
}

void QUndoStack_SetClean(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoStack*>(ptr), "setClean");
}

void QUndoStack_SetIndex(void* ptr, int idx)
{
	QMetaObject::invokeMethod(static_cast<QUndoStack*>(ptr), "setIndex", Q_ARG(int, idx));
}

char* QUndoStack_Text(void* ptr, int idx)
{
	return const_cast<char*>(static_cast<QUndoStack*>(ptr)->text(idx).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QUndoStack_Undo(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoStack*>(ptr), "undo");
}

char* QUndoStack_UndoText(void* ptr)
{
	return const_cast<char*>(static_cast<QUndoStack*>(ptr)->undoText().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QUndoStack_ConnectUndoTextChanged(void* ptr)
{
	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));
}

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, char* undoText)
{
	static_cast<QUndoStack*>(ptr)->undoTextChanged(QString(undoText));
}

void QUndoStack_DestroyQUndoStack(void* ptr)
{
	static_cast<QUndoStack*>(ptr)->~QUndoStack();
}

void QUndoStack_TimerEvent(void* ptr, void* event)
{
	static_cast<QUndoStack*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QUndoStack_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QUndoStack*>(ptr)->QUndoStack::timerEvent(static_cast<QTimerEvent*>(event));
}

void QUndoStack_ChildEvent(void* ptr, void* event)
{
	static_cast<QUndoStack*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QUndoStack_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QUndoStack*>(ptr)->QUndoStack::childEvent(static_cast<QChildEvent*>(event));
}

void QUndoStack_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QUndoStack*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QUndoStack_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QUndoStack*>(ptr)->QUndoStack::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QUndoStack_CustomEvent(void* ptr, void* event)
{
	static_cast<QUndoStack*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QUndoStack_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QUndoStack*>(ptr)->QUndoStack::customEvent(static_cast<QEvent*>(event));
}

void QUndoStack_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoStack*>(ptr), "deleteLater");
}

void QUndoStack_DeleteLaterDefault(void* ptr)
{
	static_cast<QUndoStack*>(ptr)->QUndoStack::deleteLater();
}

void QUndoStack_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QUndoStack*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QUndoStack_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QUndoStack*>(ptr)->QUndoStack::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QUndoStack_Event(void* ptr, void* e)
{
	return static_cast<QUndoStack*>(ptr)->event(static_cast<QEvent*>(e));
}

char QUndoStack_EventDefault(void* ptr, void* e)
{
	return static_cast<QUndoStack*>(ptr)->QUndoStack::event(static_cast<QEvent*>(e));
}

char QUndoStack_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QUndoStack*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QUndoStack_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QUndoStack*>(ptr)->QUndoStack::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QUndoStack_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QUndoStack*>(ptr)->metaObject());
}

void* QUndoStack_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QUndoStack*>(ptr)->QUndoStack::metaObject());
}

class MyQUndoView: public QUndoView
{
public:
	MyQUndoView(QUndoGroup *group, QWidget *parent) : QUndoView(group, parent) {};
	MyQUndoView(QUndoStack *stack, QWidget *parent) : QUndoView(stack, parent) {};
	MyQUndoView(QWidget *parent) : QUndoView(parent) {};
	void setGroup(QUndoGroup * group) { callbackQUndoView_SetGroup(this, group); };
	void setStack(QUndoStack * stack) { callbackQUndoView_SetStack(this, stack); };
	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQUndoView_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
	void dragLeaveEvent(QDragLeaveEvent * e) { callbackQUndoView_DragLeaveEvent(this, e); };
	void dragMoveEvent(QDragMoveEvent * e) { callbackQUndoView_DragMoveEvent(this, e); };
	void dropEvent(QDropEvent * e) { callbackQUndoView_DropEvent(this, e); };
	int horizontalOffset() const { return callbackQUndoView_HorizontalOffset(const_cast<MyQUndoView*>(this)); };
	QModelIndex indexAt(const QPoint & p) const { return *static_cast<QModelIndex*>(callbackQUndoView_IndexAt(const_cast<MyQUndoView*>(this), const_cast<QPoint*>(&p))); };
	bool isIndexHidden(const QModelIndex & index) const { return callbackQUndoView_IsIndexHidden(const_cast<MyQUndoView*>(this), const_cast<QModelIndex*>(&index)) != 0; };
	void mouseMoveEvent(QMouseEvent * e) { callbackQUndoView_MouseMoveEvent(this, e); };
	void mouseReleaseEvent(QMouseEvent * e) { callbackQUndoView_MouseReleaseEvent(this, e); };
	QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQUndoView_MoveCursor(this, cursorAction, modifiers)); };
	void paintEvent(QPaintEvent * e) { callbackQUndoView_PaintEvent(this, e); };
	void resizeEvent(QResizeEvent * e) { callbackQUndoView_ResizeEvent(this, e); };
	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQUndoView_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), start, end); };
	void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQUndoView_RowsInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQUndoView_ScrollTo(this, const_cast<QModelIndex*>(&index), hint); };
	void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQUndoView_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQUndoView_SetSelection(this, const_cast<QRect*>(&rect), command); };
	void startDrag(Qt::DropActions supportedActions) { callbackQUndoView_StartDrag(this, supportedActions); };
	void updateGeometries() { callbackQUndoView_UpdateGeometries(this); };
	int verticalOffset() const { return callbackQUndoView_VerticalOffset(const_cast<MyQUndoView*>(this)); };
	QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQUndoView_ViewOptions(const_cast<MyQUndoView*>(this))); };
	QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQUndoView_ViewportSizeHint(const_cast<MyQUndoView*>(this))); };
	QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQUndoView_VisualRect(const_cast<MyQUndoView*>(this), const_cast<QModelIndex*>(&index))); };
	QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQUndoView_VisualRegionForSelection(const_cast<MyQUndoView*>(this), const_cast<QItemSelection*>(&selection))); };
	void wheelEvent(QWheelEvent * e) { callbackQUndoView_WheelEvent(this, e); };
	bool viewportEvent(QEvent * event) { return callbackQUndoView_ViewportEvent(this, event) != 0; };
	void clearSelection() { callbackQUndoView_ClearSelection(this); };
	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQUndoView_CloseEditor(this, editor, hint); };
	void commitData(QWidget * editor) { callbackQUndoView_CommitData(this, editor); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQUndoView_DragEnterEvent(this, event); };
	void edit(const QModelIndex & index) { callbackQUndoView_Edit(this, const_cast<QModelIndex*>(&index)); };
	bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQUndoView_Edit2(this, const_cast<QModelIndex*>(&index), trigger, event) != 0; };
	void editorDestroyed(QObject * editor) { callbackQUndoView_EditorDestroyed(this, editor); };
	void focusInEvent(QFocusEvent * event) { callbackQUndoView_FocusInEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQUndoView_FocusNextPrevChild(this, next) != 0; };
	void focusOutEvent(QFocusEvent * event) { callbackQUndoView_FocusOutEvent(this, event); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQUndoView_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQUndoView_InputMethodQuery(const_cast<MyQUndoView*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQUndoView_KeyPressEvent(this, event); };
	void keyboardSearch(const QString & search) { callbackQUndoView_KeyboardSearch(this, const_cast<char*>(search.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQUndoView_MouseDoubleClickEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQUndoView_MousePressEvent(this, event); };
	void reset() { callbackQUndoView_Reset(this); };
	void scrollToBottom() { callbackQUndoView_ScrollToBottom(this); };
	void scrollToTop() { callbackQUndoView_ScrollToTop(this); };
	void selectAll() { callbackQUndoView_SelectAll(this); };
	QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQUndoView_SelectionCommand(const_cast<MyQUndoView*>(this), const_cast<QModelIndex*>(&index), const_cast<QEvent*>(event))); };
	void setCurrentIndex(const QModelIndex & index) { callbackQUndoView_SetCurrentIndex(this, const_cast<QModelIndex*>(&index)); };
	void setModel(QAbstractItemModel * model) { callbackQUndoView_SetModel(this, model); };
	void setRootIndex(const QModelIndex & index) { callbackQUndoView_SetRootIndex(this, const_cast<QModelIndex*>(&index)); };
	void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQUndoView_SetSelectionModel(this, selectionModel); };
	int sizeHintForColumn(int column) const { return callbackQUndoView_SizeHintForColumn(const_cast<MyQUndoView*>(this), column); };
	int sizeHintForRow(int row) const { return callbackQUndoView_SizeHintForRow(const_cast<MyQUndoView*>(this), row); };
	void update(const QModelIndex & index) { callbackQUndoView_Update(this, const_cast<QModelIndex*>(&index)); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQUndoView_ContextMenuEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQUndoView_MinimumSizeHint(const_cast<MyQUndoView*>(this))); };
	void scrollContentsBy(int dx, int dy) { callbackQUndoView_ScrollContentsBy(this, dx, dy); };
	void setupViewport(QWidget * viewport) { callbackQUndoView_SetupViewport(this, viewport); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQUndoView_SizeHint(const_cast<MyQUndoView*>(this))); };
	void changeEvent(QEvent * ev) { callbackQUndoView_ChangeEvent(this, ev); };
	void actionEvent(QActionEvent * event) { callbackQUndoView_ActionEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQUndoView_EnterEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQUndoView_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQUndoView_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQUndoView_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQUndoView_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQUndoView_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQUndoView_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQUndoView_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQUndoView_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQUndoView_ShowEvent(this, event); };
	bool close() { return callbackQUndoView_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQUndoView_CloseEvent(this, event); };
	bool hasHeightForWidth() const { return callbackQUndoView_HasHeightForWidth(const_cast<MyQUndoView*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQUndoView_HeightForWidth(const_cast<MyQUndoView*>(this), w); };
	void hide() { callbackQUndoView_Hide(this); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQUndoView_KeyReleaseEvent(this, event); };
	void lower() { callbackQUndoView_Lower(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQUndoView_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQUndoView_Raise(this); };
	void repaint() { callbackQUndoView_Repaint(this); };
	void setDisabled(bool disable) { callbackQUndoView_SetDisabled(this, disable); };
	void setFocus() { callbackQUndoView_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQUndoView_SetHidden(this, hidden); };
	void show() { callbackQUndoView_Show(this); };
	void showFullScreen() { callbackQUndoView_ShowFullScreen(this); };
	void showMaximized() { callbackQUndoView_ShowMaximized(this); };
	void showMinimized() { callbackQUndoView_ShowMinimized(this); };
	void showNormal() { callbackQUndoView_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQUndoView_TabletEvent(this, event); };
	void updateMicroFocus() { callbackQUndoView_UpdateMicroFocus(this); };
	void childEvent(QChildEvent * event) { callbackQUndoView_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQUndoView_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQUndoView_CustomEvent(this, event); };
	void deleteLater() { callbackQUndoView_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQUndoView_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQUndoView_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQUndoView_MetaObject(const_cast<MyQUndoView*>(this))); };
};

void* QUndoView_CleanIcon(void* ptr)
{
	return new QIcon(static_cast<QUndoView*>(ptr)->cleanIcon());
}

char* QUndoView_EmptyLabel(void* ptr)
{
	return const_cast<char*>(static_cast<QUndoView*>(ptr)->emptyLabel().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QUndoView_SetCleanIcon(void* ptr, void* icon)
{
	static_cast<QUndoView*>(ptr)->setCleanIcon(*static_cast<QIcon*>(icon));
}

void QUndoView_SetEmptyLabel(void* ptr, char* label)
{
	static_cast<QUndoView*>(ptr)->setEmptyLabel(QString(label));
}

void* QUndoView_NewQUndoView3(void* group, void* parent)
{
	return new MyQUndoView(static_cast<QUndoGroup*>(group), static_cast<QWidget*>(parent));
}

void* QUndoView_NewQUndoView2(void* stack, void* parent)
{
	return new MyQUndoView(static_cast<QUndoStack*>(stack), static_cast<QWidget*>(parent));
}

void* QUndoView_NewQUndoView(void* parent)
{
	return new MyQUndoView(static_cast<QWidget*>(parent));
}

void* QUndoView_Group(void* ptr)
{
	return static_cast<QUndoView*>(ptr)->group();
}

void QUndoView_SetGroup(void* ptr, void* group)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setGroup", Q_ARG(QUndoGroup*, 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_Stack(void* ptr)
{
	return static_cast<QUndoView*>(ptr)->stack();
}

void QUndoView_DestroyQUndoView(void* ptr)
{
	static_cast<QUndoView*>(ptr)->~QUndoView();
}

void QUndoView_CurrentChanged(void* ptr, void* current, void* previous)
{
	static_cast<QUndoView*>(ptr)->currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QUndoView_CurrentChangedDefault(void* ptr, void* current, void* previous)
{
	static_cast<QUndoView*>(ptr)->QUndoView::currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}

void QUndoView_DragLeaveEvent(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QUndoView_DragLeaveEventDefault(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->QUndoView::dragLeaveEvent(static_cast<QDragLeaveEvent*>(e));
}

void QUndoView_DragMoveEvent(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

void QUndoView_DragMoveEventDefault(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->QUndoView::dragMoveEvent(static_cast<QDragMoveEvent*>(e));
}

void QUndoView_DropEvent(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->dropEvent(static_cast<QDropEvent*>(e));
}

void QUndoView_DropEventDefault(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->QUndoView::dropEvent(static_cast<QDropEvent*>(e));
}

int QUndoView_HorizontalOffset(void* ptr)
{
	return static_cast<QUndoView*>(ptr)->horizontalOffset();
}

int QUndoView_HorizontalOffsetDefault(void* ptr)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::horizontalOffset();
}

void* QUndoView_IndexAt(void* ptr, void* p)
{
	return new QModelIndex(static_cast<QUndoView*>(ptr)->indexAt(*static_cast<QPoint*>(p)));
}

void* QUndoView_IndexAtDefault(void* ptr, void* p)
{
	return new QModelIndex(static_cast<QUndoView*>(ptr)->QUndoView::indexAt(*static_cast<QPoint*>(p)));
}

char QUndoView_IsIndexHidden(void* ptr, void* index)
{
	return static_cast<QUndoView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}

char QUndoView_IsIndexHiddenDefault(void* ptr, void* index)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::isIndexHidden(*static_cast<QModelIndex*>(index));
}

void QUndoView_MouseMoveEvent(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QUndoView_MouseMoveEventDefault(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->QUndoView::mouseMoveEvent(static_cast<QMouseEvent*>(e));
}

void QUndoView_MouseReleaseEvent(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void QUndoView_MouseReleaseEventDefault(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->QUndoView::mouseReleaseEvent(static_cast<QMouseEvent*>(e));
}

void* QUndoView_MoveCursor(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QUndoView*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void* QUndoView_MoveCursorDefault(void* ptr, long long cursorAction, long long modifiers)
{
	return new QModelIndex(static_cast<QUndoView*>(ptr)->QUndoView::moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}

void QUndoView_PaintEvent(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->paintEvent(static_cast<QPaintEvent*>(e));
}

void QUndoView_PaintEventDefault(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->QUndoView::paintEvent(static_cast<QPaintEvent*>(e));
}

void QUndoView_ResizeEvent(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(e));
}

void QUndoView_ResizeEventDefault(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->QUndoView::resizeEvent(static_cast<QResizeEvent*>(e));
}

void QUndoView_RowsAboutToBeRemoved(void* ptr, void* parent, int start, int end)
{
	static_cast<QUndoView*>(ptr)->rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
}

void QUndoView_RowsAboutToBeRemovedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QUndoView*>(ptr)->QUndoView::rowsAboutToBeRemoved(*static_cast<QModelIndex*>(parent), start, end);
}

void QUndoView_RowsInserted(void* ptr, void* parent, int start, int end)
{
	static_cast<QUndoView*>(ptr)->rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
}

void QUndoView_RowsInsertedDefault(void* ptr, void* parent, int start, int end)
{
	static_cast<QUndoView*>(ptr)->QUndoView::rowsInserted(*static_cast<QModelIndex*>(parent), start, end);
}

void QUndoView_ScrollTo(void* ptr, void* index, long long hint)
{
	static_cast<QUndoView*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QUndoView_ScrollToDefault(void* ptr, void* index, long long hint)
{
	static_cast<QUndoView*>(ptr)->QUndoView::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}

void QUndoView_SelectionChanged(void* ptr, void* selected, void* deselected)
{
	static_cast<QUndoView*>(ptr)->selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

void QUndoView_SelectionChangedDefault(void* ptr, void* selected, void* deselected)
{
	static_cast<QUndoView*>(ptr)->QUndoView::selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}

void QUndoView_SetSelection(void* ptr, void* rect, long long command)
{
	static_cast<QUndoView*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QUndoView_SetSelectionDefault(void* ptr, void* rect, long long command)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}

void QUndoView_StartDrag(void* ptr, long long supportedActions)
{
	static_cast<QUndoView*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QUndoView_StartDragDefault(void* ptr, long long supportedActions)
{
	static_cast<QUndoView*>(ptr)->QUndoView::startDrag(static_cast<Qt::DropAction>(supportedActions));
}

void QUndoView_UpdateGeometries(void* ptr)
{
	static_cast<QUndoView*>(ptr)->updateGeometries();
}

void QUndoView_UpdateGeometriesDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::updateGeometries();
}

int QUndoView_VerticalOffset(void* ptr)
{
	return static_cast<QUndoView*>(ptr)->verticalOffset();
}

int QUndoView_VerticalOffsetDefault(void* ptr)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::verticalOffset();
}

void* QUndoView_ViewOptions(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QUndoView*>(ptr)->viewOptions());
}

void* QUndoView_ViewOptionsDefault(void* ptr)
{
	return new QStyleOptionViewItem(static_cast<QUndoView*>(ptr)->QUndoView::viewOptions());
}

void* QUndoView_ViewportSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QUndoView*>(ptr)->viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QUndoView_ViewportSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QUndoView*>(ptr)->QUndoView::viewportSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QUndoView_VisualRect(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QUndoView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QUndoView_VisualRectDefault(void* ptr, void* index)
{
	return ({ QRect tmpValue = static_cast<QUndoView*>(ptr)->QUndoView::visualRect(*static_cast<QModelIndex*>(index)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QUndoView_VisualRegionForSelection(void* ptr, void* selection)
{
	return new QRegion(static_cast<QUndoView*>(ptr)->visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void* QUndoView_VisualRegionForSelectionDefault(void* ptr, void* selection)
{
	return new QRegion(static_cast<QUndoView*>(ptr)->QUndoView::visualRegionForSelection(*static_cast<QItemSelection*>(selection)));
}

void QUndoView_WheelEvent(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(e));
}

void QUndoView_WheelEventDefault(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->QUndoView::wheelEvent(static_cast<QWheelEvent*>(e));
}

char QUndoView_ViewportEvent(void* ptr, void* event)
{
	return static_cast<QUndoView*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}

char QUndoView_ViewportEventDefault(void* ptr, void* event)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::viewportEvent(static_cast<QEvent*>(event));
}

void QUndoView_ClearSelection(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "clearSelection");
}

void QUndoView_ClearSelectionDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::clearSelection();
}

void QUndoView_CloseEditor(void* ptr, void* editor, long long hint)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "closeEditor", Q_ARG(QWidget*, static_cast<QWidget*>(editor)), Q_ARG(QAbstractItemDelegate::EndEditHint, static_cast<QAbstractItemDelegate::EndEditHint>(hint)));
}

void QUndoView_CloseEditorDefault(void* ptr, void* editor, long long hint)
{
	static_cast<QUndoView*>(ptr)->QUndoView::closeEditor(static_cast<QWidget*>(editor), static_cast<QAbstractItemDelegate::EndEditHint>(hint));
}

void QUndoView_CommitData(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "commitData", Q_ARG(QWidget*, static_cast<QWidget*>(editor)));
}

void QUndoView_CommitDataDefault(void* ptr, void* editor)
{
	static_cast<QUndoView*>(ptr)->QUndoView::commitData(static_cast<QWidget*>(editor));
}

void QUndoView_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QUndoView_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QUndoView_Edit(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "edit", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QUndoView_EditDefault(void* ptr, void* index)
{
	static_cast<QUndoView*>(ptr)->QUndoView::edit(*static_cast<QModelIndex*>(index));
}

char QUndoView_Edit2(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QUndoView*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

char QUndoView_Edit2Default(void* ptr, void* index, long long trigger, void* event)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}

void QUndoView_EditorDestroyed(void* ptr, void* editor)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "editorDestroyed", Q_ARG(QObject*, static_cast<QObject*>(editor)));
}

void QUndoView_EditorDestroyedDefault(void* ptr, void* editor)
{
	static_cast<QUndoView*>(ptr)->QUndoView::editorDestroyed(static_cast<QObject*>(editor));
}

void QUndoView_FocusInEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QUndoView_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::focusInEvent(static_cast<QFocusEvent*>(event));
}

char QUndoView_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QUndoView*>(ptr)->focusNextPrevChild(next != 0);
}

char QUndoView_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::focusNextPrevChild(next != 0);
}

void QUndoView_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QUndoView_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QUndoView_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QUndoView_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QUndoView_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QUndoView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QUndoView_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QUndoView*>(ptr)->QUndoView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QUndoView_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QUndoView_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QUndoView_KeyboardSearch(void* ptr, char* search)
{
	static_cast<QUndoView*>(ptr)->keyboardSearch(QString(search));
}

void QUndoView_KeyboardSearchDefault(void* ptr, char* search)
{
	static_cast<QUndoView*>(ptr)->QUndoView::keyboardSearch(QString(search));
}

void QUndoView_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QUndoView_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QUndoView_MousePressEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QUndoView_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QUndoView_Reset(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "reset");
}

void QUndoView_ResetDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::reset();
}

void QUndoView_ScrollToBottom(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "scrollToBottom");
}

void QUndoView_ScrollToBottomDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::scrollToBottom();
}

void QUndoView_ScrollToTop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "scrollToTop");
}

void QUndoView_ScrollToTopDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::scrollToTop();
}

void QUndoView_SelectAll(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "selectAll");
}

void QUndoView_SelectAllDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::selectAll();
}

long long QUndoView_SelectionCommand(void* ptr, void* index, void* event)
{
	return static_cast<QUndoView*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

long long QUndoView_SelectionCommandDefault(void* ptr, void* index, void* event)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}

void QUndoView_SetCurrentIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setCurrentIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QUndoView_SetCurrentIndexDefault(void* ptr, void* index)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setCurrentIndex(*static_cast<QModelIndex*>(index));
}

void QUndoView_SetModel(void* ptr, void* model)
{
	static_cast<QUndoView*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}

void QUndoView_SetModelDefault(void* ptr, void* model)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setModel(static_cast<QAbstractItemModel*>(model));
}

void QUndoView_SetRootIndex(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setRootIndex", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QUndoView_SetRootIndexDefault(void* ptr, void* index)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setRootIndex(*static_cast<QModelIndex*>(index));
}

void QUndoView_SetSelectionModel(void* ptr, void* selectionModel)
{
	static_cast<QUndoView*>(ptr)->setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

void QUndoView_SetSelectionModelDefault(void* ptr, void* selectionModel)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setSelectionModel(static_cast<QItemSelectionModel*>(selectionModel));
}

int QUndoView_SizeHintForColumn(void* ptr, int column)
{
	return static_cast<QUndoView*>(ptr)->sizeHintForColumn(column);
}

int QUndoView_SizeHintForColumnDefault(void* ptr, int column)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::sizeHintForColumn(column);
}

int QUndoView_SizeHintForRow(void* ptr, int row)
{
	return static_cast<QUndoView*>(ptr)->sizeHintForRow(row);
}

int QUndoView_SizeHintForRowDefault(void* ptr, int row)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::sizeHintForRow(row);
}

void QUndoView_Update(void* ptr, void* index)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "update", Q_ARG(QModelIndex, *static_cast<QModelIndex*>(index)));
}

void QUndoView_UpdateDefault(void* ptr, void* index)
{
	static_cast<QUndoView*>(ptr)->QUndoView::update(*static_cast<QModelIndex*>(index));
}

void QUndoView_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QUndoView_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QUndoView*>(ptr)->QUndoView::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void* QUndoView_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QUndoView*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QUndoView_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QUndoView*>(ptr)->QUndoView::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QUndoView_ScrollContentsBy(void* ptr, int dx, int dy)
{
	static_cast<QUndoView*>(ptr)->scrollContentsBy(dx, dy);
}

void QUndoView_ScrollContentsByDefault(void* ptr, int dx, int dy)
{
	static_cast<QUndoView*>(ptr)->QUndoView::scrollContentsBy(dx, dy);
}

void QUndoView_SetupViewport(void* ptr, void* viewport)
{
	static_cast<QUndoView*>(ptr)->setupViewport(static_cast<QWidget*>(viewport));
}

void QUndoView_SetupViewportDefault(void* ptr, void* viewport)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setupViewport(static_cast<QWidget*>(viewport));
}

void* QUndoView_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QUndoView*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QUndoView_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QUndoView*>(ptr)->QUndoView::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QUndoView_ChangeEvent(void* ptr, void* ev)
{
	static_cast<QUndoView*>(ptr)->changeEvent(static_cast<QEvent*>(ev));
}

void QUndoView_ChangeEventDefault(void* ptr, void* ev)
{
	static_cast<QUndoView*>(ptr)->QUndoView::changeEvent(static_cast<QEvent*>(ev));
}

void QUndoView_ActionEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QUndoView_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::actionEvent(static_cast<QActionEvent*>(event));
}

void QUndoView_EnterEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QUndoView_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::enterEvent(static_cast<QEvent*>(event));
}

void QUndoView_HideEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QUndoView_HideEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::hideEvent(static_cast<QHideEvent*>(event));
}

void QUndoView_LeaveEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QUndoView_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::leaveEvent(static_cast<QEvent*>(event));
}

void QUndoView_MoveEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QUndoView_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::moveEvent(static_cast<QMoveEvent*>(event));
}

void QUndoView_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QUndoView_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setEnabled(vbo != 0);
}

void QUndoView_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QUndoView_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setStyleSheet(QString(styleSheet));
}

void QUndoView_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QUndoView_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setVisible(visible != 0);
}

void QUndoView_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QUndoView_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setWindowModified(vbo != 0);
}

void QUndoView_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QUndoView_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setWindowTitle(QString(vqs));
}

void QUndoView_ShowEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QUndoView_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::showEvent(static_cast<QShowEvent*>(event));
}

char QUndoView_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QUndoView_CloseDefault(void* ptr)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::close();
}

void QUndoView_CloseEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QUndoView_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::closeEvent(static_cast<QCloseEvent*>(event));
}

char QUndoView_HasHeightForWidth(void* ptr)
{
	return static_cast<QUndoView*>(ptr)->hasHeightForWidth();
}

char QUndoView_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::hasHeightForWidth();
}

int QUndoView_HeightForWidth(void* ptr, int w)
{
	return static_cast<QUndoView*>(ptr)->heightForWidth(w);
}

int QUndoView_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::heightForWidth(w);
}

void QUndoView_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "hide");
}

void QUndoView_HideDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::hide();
}

void QUndoView_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QUndoView_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QUndoView_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "lower");
}

void QUndoView_LowerDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::lower();
}

char QUndoView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QUndoView*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QUndoView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QUndoView_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "raise");
}

void QUndoView_RaiseDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::raise();
}

void QUndoView_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "repaint");
}

void QUndoView_RepaintDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::repaint();
}

void QUndoView_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QUndoView_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setDisabled(disable != 0);
}

void QUndoView_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setFocus");
}

void QUndoView_SetFocus2Default(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setFocus();
}

void QUndoView_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QUndoView_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QUndoView*>(ptr)->QUndoView::setHidden(hidden != 0);
}

void QUndoView_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "show");
}

void QUndoView_ShowDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::show();
}

void QUndoView_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "showFullScreen");
}

void QUndoView_ShowFullScreenDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::showFullScreen();
}

void QUndoView_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "showMaximized");
}

void QUndoView_ShowMaximizedDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::showMaximized();
}

void QUndoView_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "showMinimized");
}

void QUndoView_ShowMinimizedDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::showMinimized();
}

void QUndoView_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "showNormal");
}

void QUndoView_ShowNormalDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::showNormal();
}

void QUndoView_TabletEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QUndoView_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QUndoView_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "updateMicroFocus");
}

void QUndoView_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::updateMicroFocus();
}

void QUndoView_ChildEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QUndoView_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::childEvent(static_cast<QChildEvent*>(event));
}

void QUndoView_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QUndoView*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QUndoView_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QUndoView*>(ptr)->QUndoView::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QUndoView_CustomEvent(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QUndoView_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QUndoView*>(ptr)->QUndoView::customEvent(static_cast<QEvent*>(event));
}

void QUndoView_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "deleteLater");
}

void QUndoView_DeleteLaterDefault(void* ptr)
{
	static_cast<QUndoView*>(ptr)->QUndoView::deleteLater();
}

void QUndoView_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QUndoView*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QUndoView_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QUndoView*>(ptr)->QUndoView::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QUndoView_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QUndoView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QUndoView_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QUndoView*>(ptr)->QUndoView::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QUndoView_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QUndoView*>(ptr)->metaObject());
}

void* QUndoView_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QUndoView*>(ptr)->QUndoView::metaObject());
}

void* QVBoxLayout_NewQVBoxLayout()
{
	return new QVBoxLayout();
}

void* QVBoxLayout_NewQVBoxLayout2(void* parent)
{
	return new QVBoxLayout(static_cast<QWidget*>(parent));
}

void QVBoxLayout_DestroyQVBoxLayout(void* ptr)
{
	static_cast<QVBoxLayout*>(ptr)->~QVBoxLayout();
}

void QVBoxLayout_AddItem(void* ptr, void* item)
{
	static_cast<QVBoxLayout*>(ptr)->addItem(static_cast<QLayoutItem*>(item));
}

void QVBoxLayout_AddItemDefault(void* ptr, void* item)
{
	static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::addItem(static_cast<QLayoutItem*>(item));
}

int QVBoxLayout_Count(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->count();
}

int QVBoxLayout_CountDefault(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::count();
}

long long QVBoxLayout_ExpandingDirections(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->expandingDirections();
}

long long QVBoxLayout_ExpandingDirectionsDefault(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::expandingDirections();
}

char QVBoxLayout_HasHeightForWidth(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->hasHeightForWidth();
}

char QVBoxLayout_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::hasHeightForWidth();
}

int QVBoxLayout_HeightForWidth(void* ptr, int w)
{
	return static_cast<QVBoxLayout*>(ptr)->heightForWidth(w);
}

int QVBoxLayout_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::heightForWidth(w);
}

void QVBoxLayout_Invalidate(void* ptr)
{
	static_cast<QVBoxLayout*>(ptr)->invalidate();
}

void QVBoxLayout_InvalidateDefault(void* ptr)
{
	static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::invalidate();
}

void* QVBoxLayout_ItemAt(void* ptr, int index)
{
	return static_cast<QVBoxLayout*>(ptr)->itemAt(index);
}

void* QVBoxLayout_ItemAtDefault(void* ptr, int index)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::itemAt(index);
}

void* QVBoxLayout_MaximumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVBoxLayout*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QVBoxLayout_MaximumSizeDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QVBoxLayout_MinimumHeightForWidth(void* ptr, int w)
{
	return static_cast<QVBoxLayout*>(ptr)->minimumHeightForWidth(w);
}

int QVBoxLayout_MinimumHeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::minimumHeightForWidth(w);
}

void* QVBoxLayout_MinimumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVBoxLayout*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QVBoxLayout_MinimumSizeDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QVBoxLayout_SetGeometry(void* ptr, void* r)
{
	static_cast<QVBoxLayout*>(ptr)->setGeometry(*static_cast<QRect*>(r));
}

void QVBoxLayout_SetGeometryDefault(void* ptr, void* r)
{
	static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::setGeometry(*static_cast<QRect*>(r));
}

void* QVBoxLayout_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVBoxLayout*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QVBoxLayout_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QVBoxLayout_TakeAt(void* ptr, int index)
{
	return static_cast<QVBoxLayout*>(ptr)->takeAt(index);
}

void* QVBoxLayout_TakeAtDefault(void* ptr, int index)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::takeAt(index);
}

long long QVBoxLayout_ControlTypes(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->controlTypes();
}

long long QVBoxLayout_ControlTypesDefault(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::controlTypes();
}

void* QVBoxLayout_Geometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QVBoxLayout*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QVBoxLayout_GeometryDefault(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

int QVBoxLayout_IndexOf(void* ptr, void* widget)
{
	return static_cast<QVBoxLayout*>(ptr)->indexOf(static_cast<QWidget*>(widget));
}

int QVBoxLayout_IndexOfDefault(void* ptr, void* widget)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::indexOf(static_cast<QWidget*>(widget));
}

char QVBoxLayout_IsEmpty(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->isEmpty();
}

char QVBoxLayout_IsEmptyDefault(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::isEmpty();
}

void* QVBoxLayout_Layout(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->layout();
}

void* QVBoxLayout_LayoutDefault(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::layout();
}

void QVBoxLayout_TimerEvent(void* ptr, void* event)
{
	static_cast<QVBoxLayout*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QVBoxLayout_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::timerEvent(static_cast<QTimerEvent*>(event));
}

void QVBoxLayout_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QVBoxLayout*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QVBoxLayout_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QVBoxLayout_CustomEvent(void* ptr, void* event)
{
	static_cast<QVBoxLayout*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QVBoxLayout_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::customEvent(static_cast<QEvent*>(event));
}

void QVBoxLayout_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QVBoxLayout*>(ptr), "deleteLater");
}

void QVBoxLayout_DeleteLaterDefault(void* ptr)
{
	static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::deleteLater();
}

void QVBoxLayout_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QVBoxLayout*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QVBoxLayout_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QVBoxLayout_Event(void* ptr, void* e)
{
	return static_cast<QVBoxLayout*>(ptr)->event(static_cast<QEvent*>(e));
}

char QVBoxLayout_EventDefault(void* ptr, void* e)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::event(static_cast<QEvent*>(e));
}

char QVBoxLayout_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QVBoxLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QVBoxLayout_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QVBoxLayout_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QVBoxLayout*>(ptr)->metaObject());
}

void* QVBoxLayout_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::metaObject());
}

void* QVBoxLayout_SpacerItem(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->spacerItem();
}

void* QVBoxLayout_SpacerItemDefault(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::spacerItem();
}

void* QVBoxLayout_Widget(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->widget();
}

void* QVBoxLayout_WidgetDefault(void* ptr)
{
	return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::widget();
}

void* QWhatsThis_QWhatsThis_CreateAction(void* parent)
{
	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, char* text, void* w)
{
	QWhatsThis::showText(*static_cast<QPoint*>(pos), QString(text), static_cast<QWidget*>(w));
}

class MyQWidget: public QWidget
{
public:
	MyQWidget(QWidget *parent, Qt::WindowFlags f) : QWidget(parent, f) {};
	void actionEvent(QActionEvent * event) { callbackQWidget_ActionEvent(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 dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<MyQWidget*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQWidget_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQWidget_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQWidget_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<MyQWidget*>(this))); };
	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)); };
	bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<MyQWidget*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<MyQWidget*>(this), w); };
	void hide() { callbackQWidget_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<MyQWidget*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, event); };
	void lower() { callbackQWidget_Lower(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<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	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 setFocus() { callbackQWidget_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWidget_SetHidden(this, hidden); };
	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) { callbackQWidget_WindowTitleChanged(this, const_cast<char*>(title.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, event); };
	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 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<MyQWidget*>(this))); };
};

char QWidget_AcceptDrops(void* ptr)
{
	return static_cast<QWidget*>(ptr)->acceptDrops();
}

char* QWidget_AccessibleDescription(void* ptr)
{
	return const_cast<char*>(static_cast<QWidget*>(ptr)->accessibleDescription().toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QWidget_AccessibleName(void* ptr)
{
	return const_cast<char*>(static_cast<QWidget*>(ptr)->accessibleName().toUtf8().prepend("WHITESPACE").constData()+10);
}

void QWidget_ActionEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QWidget_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->QWidget::actionEvent(static_cast<QActionEvent*>(event));
}

void QWidget_ActivateWindow(void* ptr)
{
	static_cast<QWidget*>(ptr)->activateWindow();
}

char QWidget_AutoFillBackground(void* ptr)
{
	return static_cast<QWidget*>(ptr)->autoFillBackground();
}

void* QWidget_BaseSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->baseSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

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_ClearMask(void* ptr)
{
	static_cast<QWidget*>(ptr)->clearMask();
}

long long QWidget_ContextMenuPolicy(void* ptr)
{
	return static_cast<QWidget*>(ptr)->contextMenuPolicy();
}

void* QWidget_Cursor(void* ptr)
{
	return new QCursor(static_cast<QWidget*>(ptr)->cursor());
}

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)
{
	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)
{
	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)
{
	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)
{
	static_cast<QWidget*>(ptr)->QWidget::dropEvent(static_cast<QDropEvent*>(event));
}

void QWidget_EnterEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QWidget_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->QWidget::enterEvent(static_cast<QEvent*>(event));
}

void QWidget_FocusInEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QWidget_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->QWidget::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QWidget_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QWidget_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->QWidget::focusOutEvent(static_cast<QFocusEvent*>(event));
}

long long QWidget_FocusPolicy(void* ptr)
{
	return static_cast<QWidget*>(ptr)->focusPolicy();
}

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_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));
}

char QWidget_HasFocus(void* ptr)
{
	return static_cast<QWidget*>(ptr)->hasFocus();
}

void QWidget_HideEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QWidget_HideEventDefault(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->QWidget::hideEvent(static_cast<QHideEvent*>(event));
}

long long QWidget_InputMethodHints(void* ptr)
{
	return static_cast<QWidget*>(ptr)->inputMethodHints();
}

char QWidget_IsActiveWindow(void* ptr)
{
	return static_cast<QWidget*>(ptr)->isActiveWindow();
}

char QWidget_IsFullScreen(void* ptr)
{
	return static_cast<QWidget*>(ptr)->isFullScreen();
}

char QWidget_IsMaximized(void* ptr)
{
	return static_cast<QWidget*>(ptr)->isMaximized();
}

char QWidget_IsMinimized(void* ptr)
{
	return static_cast<QWidget*>(ptr)->isMinimized();
}

char QWidget_IsWindowModified(void* ptr)
{
	return static_cast<QWidget*>(ptr)->isWindowModified();
}

void* QWidget_QWidget_KeyboardGrabber()
{
	return QWidget::keyboardGrabber();
}

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)
{
	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_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_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_MaximumSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

int QWidget_Metric(void* ptr, long long m)
{
	return static_cast<QWidget*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
}

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)
{
	return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->QWidget::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWidget_QWidget_MouseGrabber()
{
	return QWidget::mouseGrabber();
}

void QWidget_Move(void* ptr, void* vqp)
{
	static_cast<QWidget*>(ptr)->move(*static_cast<QPoint*>(vqp));
}

void QWidget_MoveEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QWidget_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->QWidget::moveEvent(static_cast<QMoveEvent*>(event));
}

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_PaintEngine(void* ptr)
{
	return static_cast<QWidget*>(ptr)->paintEngine();
}

void QWidget_PaintEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QWidget_PaintEventDefault(void* ptr, void* event)
{
	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_Pos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QWidget*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QWidget_ReleaseKeyboard(void* ptr)
{
	static_cast<QWidget*>(ptr)->releaseKeyboard();
}

void QWidget_ReleaseMouse(void* ptr)
{
	static_cast<QWidget*>(ptr)->releaseMouse();
}

void QWidget_Resize(void* ptr, void* vqs)
{
	static_cast<QWidget*>(ptr)->resize(*static_cast<QSize*>(vqs));
}

void QWidget_SetAcceptDrops(void* ptr, char on)
{
	static_cast<QWidget*>(ptr)->setAcceptDrops(on != 0);
}

void QWidget_SetAccessibleDescription(void* ptr, char* description)
{
	static_cast<QWidget*>(ptr)->setAccessibleDescription(QString(description));
}

void QWidget_SetAccessibleName(void* ptr, char* name)
{
	static_cast<QWidget*>(ptr)->setAccessibleName(QString(name));
}

void QWidget_SetAutoFillBackground(void* ptr, char enabled)
{
	static_cast<QWidget*>(ptr)->setAutoFillBackground(enabled != 0);
}

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_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_SetFixedSize2(void* ptr, int w, int h)
{
	static_cast<QWidget*>(ptr)->setFixedSize(w, h);
}

void QWidget_SetFocusPolicy(void* ptr, long long policy)
{
	static_cast<QWidget*>(ptr)->setFocusPolicy(static_cast<Qt::FocusPolicy>(policy));
}

void QWidget_SetFont(void* ptr, void* vqf)
{
	static_cast<QWidget*>(ptr)->setFont(*static_cast<QFont*>(vqf));
}

void QWidget_SetGeometry(void* ptr, void* vqr)
{
	static_cast<QWidget*>(ptr)->setGeometry(*static_cast<QRect*>(vqr));
}

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_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_SetMinimumWidth(void* ptr, int minw)
{
	static_cast<QWidget*>(ptr)->setMinimumWidth(minw);
}

void QWidget_SetPalette(void* ptr, void* vqp)
{
	static_cast<QWidget*>(ptr)->setPalette(*static_cast<QPalette*>(vqp));
}

void QWidget_SetSizePolicy(void* ptr, void* vqs)
{
	static_cast<QWidget*>(ptr)->setSizePolicy(*static_cast<QSizePolicy*>(vqs));
}

void QWidget_SetStatusTip(void* ptr, char* vqs)
{
	static_cast<QWidget*>(ptr)->setStatusTip(QString(vqs));
}

void QWidget_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QWidget_SetToolTip(void* ptr, char* vqs)
{
	static_cast<QWidget*>(ptr)->setToolTip(QString(vqs));
}

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)
{
	static_cast<QWidget*>(ptr)->QWidget::setVisible(visible != 0);
}

void QWidget_SetWhatsThis(void* ptr, char* vqs)
{
	static_cast<QWidget*>(ptr)->setWhatsThis(QString(vqs));
}

void QWidget_SetWindowFilePath(void* ptr, char* filePath)
{
	static_cast<QWidget*>(ptr)->setWindowFilePath(QString(filePath));
}

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, char* vqs)
{
	static_cast<QWidget*>(ptr)->setWindowIconText(QString(vqs));
}

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_SetWindowOpacity(void* ptr, double level)
{
	static_cast<QWidget*>(ptr)->setWindowOpacity(level);
}

void QWidget_SetWindowState(void* ptr, long long windowState)
{
	static_cast<QWidget*>(ptr)->setWindowState(static_cast<Qt::WindowState>(windowState));
}

void QWidget_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QWidget_ShowEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QWidget_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->QWidget::showEvent(static_cast<QShowEvent*>(event));
}

void* QWidget_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWidget_SizeHintDefault(void* ptr)
{
	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()); });
}

char* QWidget_StatusTip(void* ptr)
{
	return const_cast<char*>(static_cast<QWidget*>(ptr)->statusTip().toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QWidget_StyleSheet(void* ptr)
{
	return const_cast<char*>(static_cast<QWidget*>(ptr)->styleSheet().toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QWidget_ToolTip(void* ptr)
{
	return const_cast<char*>(static_cast<QWidget*>(ptr)->toolTip().toUtf8().prepend("WHITESPACE").constData()+10);
}

int QWidget_ToolTipDuration(void* ptr)
{
	return static_cast<QWidget*>(ptr)->toolTipDuration();
}

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();
}

char* QWidget_WhatsThis(void* ptr)
{
	return const_cast<char*>(static_cast<QWidget*>(ptr)->whatsThis().toUtf8().prepend("WHITESPACE").constData()+10);
}

uintptr_t QWidget_WinId(void* ptr)
{
	return static_cast<QWidget*>(ptr)->winId();
}

char* QWidget_WindowFilePath(void* ptr)
{
	return const_cast<char*>(static_cast<QWidget*>(ptr)->windowFilePath().toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QWidget_WindowIcon(void* ptr)
{
	return new QIcon(static_cast<QWidget*>(ptr)->windowIcon());
}

char* QWidget_WindowIconText(void* ptr)
{
	return const_cast<char*>(static_cast<QWidget*>(ptr)->windowIconText().toUtf8().prepend("WHITESPACE").constData()+10);
}

long long QWidget_WindowModality(void* ptr)
{
	return static_cast<QWidget*>(ptr)->windowModality();
}

double QWidget_WindowOpacity(void* ptr)
{
	return static_cast<QWidget*>(ptr)->windowOpacity();
}

char* QWidget_WindowTitle(void* ptr)
{
	return const_cast<char*>(static_cast<QWidget*>(ptr)->windowTitle().toUtf8().prepend("WHITESPACE").constData()+10);
}

int QWidget_X(void* ptr)
{
	return static_cast<QWidget*>(ptr)->x();
}

int QWidget_Y(void* ptr)
{
	return static_cast<QWidget*>(ptr)->y();
}

void* QWidget_NewQWidget(void* parent, long long f)
{
	return new MyQWidget(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
}

void QWidget_AddAction(void* ptr, void* action)
{
	static_cast<QWidget*>(ptr)->addAction(static_cast<QAction*>(action));
}

void QWidget_AdjustSize(void* ptr)
{
	static_cast<QWidget*>(ptr)->adjustSize();
}

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_ChangeEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QWidget_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->QWidget::changeEvent(static_cast<QEvent*>(event));
}

void* QWidget_ChildAt2(void* ptr, void* p)
{
	return static_cast<QWidget*>(ptr)->childAt(*static_cast<QPoint*>(p));
}

void* QWidget_ChildAt(void* ptr, int x, int y)
{
	return static_cast<QWidget*>(ptr)->childAt(x, y);
}

void QWidget_ClearFocus(void* ptr)
{
	static_cast<QWidget*>(ptr)->clearFocus();
}

char QWidget_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

void QWidget_CloseEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QWidget_CloseEventDefault(void* ptr, void* event)
{
	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)
{
	static_cast<QWidget*>(ptr)->QWidget::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QWidget_Create(void* ptr, uintptr_t window, char initializeWindow, char destroyOldWindow)
{
	static_cast<QWidget*>(ptr)->create(window, initializeWindow != 0, destroyOldWindow != 0);
}

void QWidget_ConnectCustomContextMenuRequested(void* ptr)
{
	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));
}

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));
}

char QWidget_Event(void* ptr, void* event)
{
	return static_cast<QWidget*>(ptr)->event(static_cast<QEvent*>(event));
}

void* QWidget_QWidget_Find(uintptr_t id)
{
	return QWidget::find(id);
}

uintptr_t QWidget_EffectiveWinId(void* ptr)
{
	return static_cast<QWidget*>(ptr)->effectiveWinId();
}

void QWidget_EnsurePolished(void* ptr)
{
	static_cast<QWidget*>(ptr)->ensurePolished();
}

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)
{
	return static_cast<QWidget*>(ptr)->QWidget::focusNextPrevChild(next != 0);
}

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_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));
}

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_HasHeightForWidth(void* ptr)
{
	return static_cast<QWidget*>(ptr)->hasHeightForWidth();
}

char QWidget_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QWidget*>(ptr)->QWidget::hasHeightForWidth();
}

char QWidget_HasMouseTracking(void* ptr)
{
	return static_cast<QWidget*>(ptr)->hasMouseTracking();
}

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)
{
	return static_cast<QWidget*>(ptr)->QWidget::heightForWidth(w);
}

void QWidget_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "hide");
}

void QWidget_InitPainter(void* ptr, void* painter)
{
	static_cast<QWidget*>(ptr)->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)
{
	static_cast<QWidget*>(ptr)->QWidget::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

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)
{
	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));
}

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_IsHidden(void* ptr)
{
	return static_cast<QWidget*>(ptr)->isHidden();
}

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();
}

void QWidget_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QWidget_KeyPressEventDefault(void* ptr, void* event)
{
	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)
{
	static_cast<QWidget*>(ptr)->QWidget::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void* QWidget_Layout(void* ptr)
{
	return static_cast<QWidget*>(ptr)->layout();
}

void QWidget_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "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_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_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();
}

int QWidget_MaximumWidth(void* ptr)
{
	return static_cast<QWidget*>(ptr)->maximumWidth();
}

int QWidget_MinimumHeight(void* ptr)
{
	return static_cast<QWidget*>(ptr)->minimumHeight();
}

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)
{
	static_cast<QWidget*>(ptr)->QWidget::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QWidget_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QWidget_MouseMoveEventDefault(void* ptr, void* event)
{
	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)
{
	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)
{
	static_cast<QWidget*>(ptr)->QWidget::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QWidget_Move2(void* ptr, int x, int y)
{
	static_cast<QWidget*>(ptr)->move(x, y);
}

char QWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QWidget*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QWidget*>(ptr)->QWidget::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), 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_OverrideWindowFlags(void* ptr, long long flags)
{
	static_cast<QWidget*>(ptr)->overrideWindowFlags(static_cast<Qt::WindowType>(flags));
}

void* QWidget_ParentWidget(void* ptr)
{
	return static_cast<QWidget*>(ptr)->parentWidget();
}

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_Rect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QWidget*>(ptr)->rect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

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)
{
	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_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_Repaint2(void* ptr, int x, int y, int w, int h)
{
	static_cast<QWidget*>(ptr)->repaint(x, y, w, h);
}

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)
{
	static_cast<QWidget*>(ptr)->QWidget::resizeEvent(static_cast<QResizeEvent*>(event));
}

char QWidget_RestoreGeometry(void* ptr, char* geometry)
{
	return static_cast<QWidget*>(ptr)->restoreGeometry(QByteArray::fromHex(QString(geometry).toUtf8()));
}

char* QWidget_SaveGeometry(void* ptr)
{
	return const_cast<char*>(static_cast<QWidget*>(ptr)->saveGeometry().toHex().prepend("WHITESPACE").constData()+10);
}

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_SetAttribute(void* ptr, long long attribute, char on)
{
	static_cast<QWidget*>(ptr)->setAttribute(static_cast<Qt::WidgetAttribute>(attribute), on != 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_SetContentsMargins2(void* ptr, void* margins)
{
	static_cast<QWidget*>(ptr)->setContentsMargins(*static_cast<QMargins*>(margins));
}

void QWidget_SetContentsMargins(void* ptr, int left, int top, int right, int bottom)
{
	static_cast<QWidget*>(ptr)->setContentsMargins(left, top, right, bottom);
}

void QWidget_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 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_SetFixedWidth(void* ptr, int w)
{
	static_cast<QWidget*>(ptr)->setFixedWidth(w);
}

void QWidget_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "setFocus");
}

void QWidget_SetFocus(void* ptr, long long reason)
{
	static_cast<QWidget*>(ptr)->setFocus(static_cast<Qt::FocusReason>(reason));
}

void QWidget_SetFocusProxy(void* ptr, void* w)
{
	static_cast<QWidget*>(ptr)->setFocusProxy(static_cast<QWidget*>(w));
}

void QWidget_SetForegroundRole(void* ptr, long long role)
{
	static_cast<QWidget*>(ptr)->setForegroundRole(static_cast<QPalette::ColorRole>(role));
}

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_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_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_SetMouseTracking(void* ptr, char enable)
{
	static_cast<QWidget*>(ptr)->setMouseTracking(enable != 0);
}

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 f)
{
	static_cast<QWidget*>(ptr)->setParent(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
}

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_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_SetStyle(void* ptr, void* style)
{
	static_cast<QWidget*>(ptr)->setStyle(static_cast<QStyle*>(style));
}

void QWidget_QWidget_SetTabOrder(void* first, void* second)
{
	QWidget::setTabOrder(static_cast<QWidget*>(first), static_cast<QWidget*>(second));
}

void QWidget_SetWindowRole(void* ptr, char* role)
{
	static_cast<QWidget*>(ptr)->setWindowRole(QString(role));
}

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_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "showFullScreen");
}

void QWidget_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "showMaximized");
}

void QWidget_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "showMinimized");
}

void QWidget_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "showNormal");
}

void* QWidget_Size(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWidget*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QWidget_StackUnder(void* ptr, void* w)
{
	static_cast<QWidget*>(ptr)->stackUnder(static_cast<QWidget*>(w));
}

void* QWidget_Style(void* ptr)
{
	return static_cast<QWidget*>(ptr)->style();
}

void QWidget_TabletEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QWidget_TabletEventDefault(void* ptr, void* event)
{
	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));
}

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_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "update");
}

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_Update2(void* ptr, int x, int y, int w, int h)
{
	static_cast<QWidget*>(ptr)->update(x, y, w, h);
}

void QWidget_UpdateGeometry(void* ptr)
{
	static_cast<QWidget*>(ptr)->updateGeometry();
}

void QWidget_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "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());
}

void QWidget_WheelEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QWidget_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->QWidget::wheelEvent(static_cast<QWheelEvent*>(event));
}

int QWidget_Width(void* ptr)
{
	return static_cast<QWidget*>(ptr)->width();
}

void* QWidget_Window(void* ptr)
{
	return static_cast<QWidget*>(ptr)->window();
}

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_ConnectWindowIconChanged(void* ptr)
{
	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));
}

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));
}

char* QWidget_WindowRole(void* ptr)
{
	return const_cast<char*>(static_cast<QWidget*>(ptr)->windowRole().toUtf8().prepend("WHITESPACE").constData()+10);
}

long long QWidget_WindowState(void* ptr)
{
	return static_cast<QWidget*>(ptr)->windowState();
}

void QWidget_ConnectWindowTitleChanged(void* ptr)
{
	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));
}

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, char* title)
{
	static_cast<QWidget*>(ptr)->windowTitleChanged(QString(title));
}

long long QWidget_WindowType(void* ptr)
{
	return static_cast<QWidget*>(ptr)->windowType();
}

void QWidget_DestroyQWidget(void* ptr)
{
	static_cast<QWidget*>(ptr)->~QWidget();
}

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_TimerEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QWidget_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->QWidget::timerEvent(static_cast<QTimerEvent*>(event));
}

void QWidget_ChildEvent(void* ptr, void* event)
{
	static_cast<QWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QWidget_ChildEventDefault(void* ptr, void* event)
{
	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)
{
	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)
{
	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)
{
	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)
{
	static_cast<QWidget*>(ptr)->QWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QWidget_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QWidget_EventFilterDefault(void* ptr, void* watched, void* event)
{
	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)
{
	return const_cast<QMetaObject*>(static_cast<QWidget*>(ptr)->QWidget::metaObject());
}

class MyQWidgetAction: public QWidgetAction
{
public:
	MyQWidgetAction(QObject *parent) : QWidgetAction(parent) {};
	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 callbackQWidgetAction_Event(this, event) != 0; };
	bool eventFilter(QObject * obj, QEvent * event) { return callbackQWidgetAction_EventFilter(this, obj, event) != 0; };
	 ~MyQWidgetAction() { callbackQWidgetAction_DestroyQWidgetAction(this); };
	void setChecked(bool vbo) { callbackQWidgetAction_SetChecked(this, vbo); };
	void setEnabled(bool vbo) { callbackQWidgetAction_SetEnabled(this, vbo); };
	void setVisible(bool vbo) { callbackQWidgetAction_SetVisible(this, vbo); };
	void toggle() { callbackQWidgetAction_Toggle(this); };
	void hover() { callbackQWidgetAction_Hover(this); };
	void setDisabled(bool b) { callbackQWidgetAction_SetDisabled(this, b); };
	void trigger() { callbackQWidgetAction_Trigger(this); };
	void timerEvent(QTimerEvent * event) { callbackQWidgetAction_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQWidgetAction_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWidgetAction_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWidgetAction_CustomEvent(this, event); };
	void deleteLater() { callbackQWidgetAction_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWidgetAction_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidgetAction_MetaObject(const_cast<MyQWidgetAction*>(this))); };
};

void* QWidgetAction_NewQWidgetAction(void* parent)
{
	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));
}

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));
}

char QWidgetAction_Event(void* ptr, void* event)
{
	return static_cast<QWidgetAction*>(ptr)->event(static_cast<QEvent*>(event));
}

char QWidgetAction_EventDefault(void* ptr, void* event)
{
	return static_cast<QWidgetAction*>(ptr)->QWidgetAction::event(static_cast<QEvent*>(event));
}

char QWidgetAction_EventFilter(void* ptr, void* obj, void* event)
{
	return static_cast<QWidgetAction*>(ptr)->eventFilter(static_cast<QObject*>(obj), static_cast<QEvent*>(event));
}

char QWidgetAction_EventFilterDefault(void* ptr, void* obj, void* event)
{
	return static_cast<QWidgetAction*>(ptr)->QWidgetAction::eventFilter(static_cast<QObject*>(obj), static_cast<QEvent*>(event));
}

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)
{

}

void QWidgetAction_SetChecked(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QWidgetAction*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}

void QWidgetAction_SetCheckedDefault(void* ptr, char vbo)
{
	static_cast<QWidgetAction*>(ptr)->QWidgetAction::setChecked(vbo != 0);
}

void QWidgetAction_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QWidgetAction*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QWidgetAction_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QWidgetAction*>(ptr)->QWidgetAction::setEnabled(vbo != 0);
}

void QWidgetAction_SetVisible(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QWidgetAction*>(ptr), "setVisible", Q_ARG(bool, vbo != 0));
}

void QWidgetAction_SetVisibleDefault(void* ptr, char vbo)
{
	static_cast<QWidgetAction*>(ptr)->QWidgetAction::setVisible(vbo != 0);
}

void QWidgetAction_Toggle(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWidgetAction*>(ptr), "toggle");
}

void QWidgetAction_ToggleDefault(void* ptr)
{
	static_cast<QWidgetAction*>(ptr)->QWidgetAction::toggle();
}

void QWidgetAction_Hover(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWidgetAction*>(ptr), "hover");
}

void QWidgetAction_HoverDefault(void* ptr)
{
	static_cast<QWidgetAction*>(ptr)->QWidgetAction::hover();
}

void QWidgetAction_SetDisabled(void* ptr, char b)
{
	QMetaObject::invokeMethod(static_cast<QWidgetAction*>(ptr), "setDisabled", Q_ARG(bool, b != 0));
}

void QWidgetAction_SetDisabledDefault(void* ptr, char b)
{
	static_cast<QWidgetAction*>(ptr)->QWidgetAction::setDisabled(b != 0);
}

void QWidgetAction_Trigger(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWidgetAction*>(ptr), "trigger");
}

void QWidgetAction_TriggerDefault(void* ptr)
{
	static_cast<QWidgetAction*>(ptr)->QWidgetAction::trigger();
}

void QWidgetAction_TimerEvent(void* ptr, void* event)
{
	static_cast<QWidgetAction*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QWidgetAction_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QWidgetAction*>(ptr)->QWidgetAction::timerEvent(static_cast<QTimerEvent*>(event));
}

void QWidgetAction_ChildEvent(void* ptr, void* event)
{
	static_cast<QWidgetAction*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QWidgetAction_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QWidgetAction*>(ptr)->QWidgetAction::childEvent(static_cast<QChildEvent*>(event));
}

void QWidgetAction_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QWidgetAction*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QWidgetAction_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QWidgetAction*>(ptr)->QWidgetAction::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QWidgetAction_CustomEvent(void* ptr, void* event)
{
	static_cast<QWidgetAction*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QWidgetAction_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QWidgetAction*>(ptr)->QWidgetAction::customEvent(static_cast<QEvent*>(event));
}

void QWidgetAction_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWidgetAction*>(ptr), "deleteLater");
}

void QWidgetAction_DeleteLaterDefault(void* ptr)
{
	static_cast<QWidgetAction*>(ptr)->QWidgetAction::deleteLater();
}

void QWidgetAction_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QWidgetAction*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QWidgetAction_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QWidgetAction*>(ptr)->QWidgetAction::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void* QWidgetAction_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QWidgetAction*>(ptr)->metaObject());
}

void* QWidgetAction_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QWidgetAction*>(ptr)->QWidgetAction::metaObject());
}

class MyQWidgetItem: public QWidgetItem
{
public:
	MyQWidgetItem(QWidget *widget) : QWidgetItem(widget) {};
	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQWidgetItem_ControlTypes(const_cast<MyQWidgetItem*>(this))); };
	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQWidgetItem_ExpandingDirections(const_cast<MyQWidgetItem*>(this))); };
	QRect geometry() const { return *static_cast<QRect*>(callbackQWidgetItem_Geometry(const_cast<MyQWidgetItem*>(this))); };
	bool hasHeightForWidth() const { return callbackQWidgetItem_HasHeightForWidth(const_cast<MyQWidgetItem*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQWidgetItem_HeightForWidth(const_cast<MyQWidgetItem*>(this), w); };
	bool isEmpty() const { return callbackQWidgetItem_IsEmpty(const_cast<MyQWidgetItem*>(this)) != 0; };
	QSize maximumSize() const { return *static_cast<QSize*>(callbackQWidgetItem_MaximumSize(const_cast<MyQWidgetItem*>(this))); };
	QSize minimumSize() const { return *static_cast<QSize*>(callbackQWidgetItem_MinimumSize(const_cast<MyQWidgetItem*>(this))); };
	void setGeometry(const QRect & rect) { callbackQWidgetItem_SetGeometry(this, const_cast<QRect*>(&rect)); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidgetItem_SizeHint(const_cast<MyQWidgetItem*>(this))); };
	QWidget * widget() { return static_cast<QWidget*>(callbackQWidgetItem_Widget(this)); };
	void invalidate() { callbackQWidgetItem_Invalidate(this); };
	QLayout * layout() { return static_cast<QLayout*>(callbackQWidgetItem_Layout(this)); };
	int minimumHeightForWidth(int w) const { return callbackQWidgetItem_MinimumHeightForWidth(const_cast<MyQWidgetItem*>(this), w); };
	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQWidgetItem_SpacerItem(this)); };
};

void* QWidgetItem_NewQWidgetItem(void* widget)
{
	return new MyQWidgetItem(static_cast<QWidget*>(widget));
}

long long QWidgetItem_ControlTypes(void* ptr)
{
	return static_cast<QWidgetItem*>(ptr)->controlTypes();
}

long long QWidgetItem_ControlTypesDefault(void* ptr)
{
	return static_cast<QWidgetItem*>(ptr)->QWidgetItem::controlTypes();
}

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_HasHeightForWidth(void* ptr)
{
	return static_cast<QWidgetItem*>(ptr)->hasHeightForWidth();
}

char QWidgetItem_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QWidgetItem*>(ptr)->QWidgetItem::hasHeightForWidth();
}

int QWidgetItem_HeightForWidth(void* ptr, int w)
{
	return static_cast<QWidgetItem*>(ptr)->heightForWidth(w);
}

int QWidgetItem_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QWidgetItem*>(ptr)->QWidgetItem::heightForWidth(w);
}

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_Widget(void* ptr)
{
	return static_cast<QWidgetItem*>(ptr)->widget();
}

void* QWidgetItem_WidgetDefault(void* ptr)
{
	return static_cast<QWidgetItem*>(ptr)->QWidgetItem::widget();
}

void QWidgetItem_DestroyQWidgetItem(void* ptr)
{
	static_cast<QWidgetItem*>(ptr)->~QWidgetItem();
}

void* QWidgetItem_Wid(void* ptr)
{
	return static_cast<QWidgetItem*>(ptr)->wid;
}

void QWidgetItem_SetWid(void* ptr, void* vqw)
{
	static_cast<QWidgetItem*>(ptr)->wid = static_cast<QWidget*>(vqw);
}

void QWidgetItem_Invalidate(void* ptr)
{
	static_cast<QWidgetItem*>(ptr)->invalidate();
}

void QWidgetItem_InvalidateDefault(void* ptr)
{
	static_cast<QWidgetItem*>(ptr)->QWidgetItem::invalidate();
}

void* QWidgetItem_Layout(void* ptr)
{
	return static_cast<QWidgetItem*>(ptr)->layout();
}

void* QWidgetItem_LayoutDefault(void* ptr)
{
	return static_cast<QWidgetItem*>(ptr)->QWidgetItem::layout();
}

int QWidgetItem_MinimumHeightForWidth(void* ptr, int w)
{
	return static_cast<QWidgetItem*>(ptr)->minimumHeightForWidth(w);
}

int QWidgetItem_MinimumHeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QWidgetItem*>(ptr)->QWidgetItem::minimumHeightForWidth(w);
}

void* QWidgetItem_SpacerItem(void* ptr)
{
	return static_cast<QWidgetItem*>(ptr)->spacerItem();
}

void* QWidgetItem_SpacerItemDefault(void* ptr)
{
	return static_cast<QWidgetItem*>(ptr)->QWidgetItem::spacerItem();
}

class MyQWizard: public QWizard
{
public:
	MyQWizard(QWidget *parent, Qt::WindowFlags flags) : QWizard(parent, flags) {};
	void cleanupPage(int id) { callbackQWizard_CleanupPage(this, id); };
	void initializePage(int id) { callbackQWizard_InitializePage(this, id); };
	void back() { callbackQWizard_Back(this); };
	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); };
	void Signal_HelpRequested() { callbackQWizard_HelpRequested(this); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWizard_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void next() { callbackQWizard_Next(this); };
	int nextId() const { return callbackQWizard_NextId(const_cast<MyQWizard*>(this)); };
	void Signal_PageAdded(int id) { callbackQWizard_PageAdded(this, id); };
	void Signal_PageRemoved(int id) { callbackQWizard_PageRemoved(this, id); };
	void paintEvent(QPaintEvent * event) { callbackQWizard_PaintEvent(this, event); };
	void resizeEvent(QResizeEvent * event) { callbackQWizard_ResizeEvent(this, event); };
	void restart() { callbackQWizard_Restart(this); };
	void setVisible(bool visible) { callbackQWizard_SetVisible(this, visible); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWizard_SizeHint(const_cast<MyQWizard*>(this))); };
	bool validateCurrentPage() { return callbackQWizard_ValidateCurrentPage(this) != 0; };
	void accept() { callbackQWizard_Accept(this); };
	void closeEvent(QCloseEvent * e) { callbackQWizard_CloseEvent(this, e); };
	void contextMenuEvent(QContextMenuEvent * e) { callbackQWizard_ContextMenuEvent(this, e); };
	int exec() { return callbackQWizard_Exec(this); };
	void keyPressEvent(QKeyEvent * e) { callbackQWizard_KeyPressEvent(this, e); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWizard_MinimumSizeHint(const_cast<MyQWizard*>(this))); };
	void open() { callbackQWizard_Open(this); };
	void reject() { callbackQWizard_Reject(this); };
	void showEvent(QShowEvent * event) { callbackQWizard_ShowEvent(this, event); };
	void actionEvent(QActionEvent * event) { callbackQWizard_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWizard_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWizard_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWizard_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWizard_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWizard_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWizard_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQWizard_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQWizard_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWizard_LeaveEvent(this, event); };
	void moveEvent(QMoveEvent * event) { callbackQWizard_MoveEvent(this, event); };
	void setEnabled(bool vbo) { callbackQWizard_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQWizard_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setWindowModified(bool vbo) { callbackQWizard_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQWizard_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void changeEvent(QEvent * event) { callbackQWizard_ChangeEvent(this, event); };
	bool close() { return callbackQWizard_Close(this) != 0; };
	bool focusNextPrevChild(bool next) { return callbackQWizard_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWizard_HasHeightForWidth(const_cast<MyQWizard*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQWizard_HeightForWidth(const_cast<MyQWizard*>(this), w); };
	void hide() { callbackQWizard_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWizard_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWizard_InputMethodQuery(const_cast<MyQWizard*>(this), query)); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWizard_KeyReleaseEvent(this, event); };
	void lower() { callbackQWizard_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWizard_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWizard_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWizard_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWizard_MouseReleaseEvent(this, event); };
	void raise() { callbackQWizard_Raise(this); };
	void repaint() { callbackQWizard_Repaint(this); };
	void setDisabled(bool disable) { callbackQWizard_SetDisabled(this, disable); };
	void setFocus() { callbackQWizard_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWizard_SetHidden(this, hidden); };
	void show() { callbackQWizard_Show(this); };
	void showFullScreen() { callbackQWizard_ShowFullScreen(this); };
	void showMaximized() { callbackQWizard_ShowMaximized(this); };
	void showMinimized() { callbackQWizard_ShowMinimized(this); };
	void showNormal() { callbackQWizard_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWizard_TabletEvent(this, event); };
	void update() { callbackQWizard_Update(this); };
	void updateMicroFocus() { callbackQWizard_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWizard_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQWizard_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQWizard_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWizard_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWizard_CustomEvent(this, event); };
	void deleteLater() { callbackQWizard_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWizard_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWizard_MetaObject(const_cast<MyQWizard*>(this))); };
};

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();
}

char QWizard_HasVisitedPage(void* ptr, int id)
{
	return static_cast<QWizard*>(ptr)->hasVisitedPage(id);
}

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);
}

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_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_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));
}

int QWizard_StartId(void* ptr)
{
	return static_cast<QWizard*>(ptr)->startId();
}

long long QWizard_SubTitleFormat(void* ptr)
{
	return static_cast<QWizard*>(ptr)->subTitleFormat();
}

long long QWizard_TitleFormat(void* ptr)
{
	return static_cast<QWizard*>(ptr)->titleFormat();
}

long long QWizard_WizardStyle(void* ptr)
{
	return static_cast<QWizard*>(ptr)->wizardStyle();
}

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_Button(void* ptr, long long which)
{
	return static_cast<QWizard*>(ptr)->button(static_cast<QWizard::WizardButton>(which));
}

char* QWizard_ButtonText(void* ptr, long long which)
{
	return const_cast<char*>(static_cast<QWizard*>(ptr)->buttonText(static_cast<QWizard::WizardButton>(which)).toUtf8().prepend("WHITESPACE").constData()+10);
}

void QWizard_ConnectCurrentIdChanged(void* ptr)
{
	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));
}

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)
{
	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));
}

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);
}

char QWizard_Event(void* ptr, void* event)
{
	return static_cast<QWizard*>(ptr)->event(static_cast<QEvent*>(event));
}

void* QWizard_Field(void* ptr, char* name)
{
	return new QVariant(static_cast<QWizard*>(ptr)->field(QString(name)));
}

void QWizard_ConnectHelpRequested(void* ptr)
{
	QObject::connect(static_cast<QWizard*>(ptr), static_cast<void (QWizard::*)()>(&QWizard::helpRequested), static_cast<MyQWizard*>(ptr), static_cast<void (MyQWizard::*)()>(&MyQWizard::Signal_HelpRequested));
}

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();
}

char QWizard_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QWizard*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QWizard_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QWizard*>(ptr)->QWizard::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QWizard_Next(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "next");
}

int QWizard_NextId(void* ptr)
{
	return static_cast<QWizard*>(ptr)->nextId();
}

int QWizard_NextIdDefault(void* ptr)
{
	return static_cast<QWizard*>(ptr)->QWizard::nextId();
}

void QWizard_ConnectPageAdded(void* ptr)
{
	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));
}

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);
}

void QWizard_ConnectPageRemoved(void* ptr)
{
	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));
}

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_PaintEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QWizard_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::paintEvent(static_cast<QPaintEvent*>(event));
}

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_ResizeEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QWizard_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QWizard_Restart(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "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, char* text)
{
	static_cast<QWizard*>(ptr)->setButtonText(static_cast<QWizard::WizardButton>(which), QString(text));
}

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, char* name, void* value)
{
	static_cast<QWizard*>(ptr)->setField(QString(name), *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_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_SetVisible(void* ptr, char visible)
{
	static_cast<QWizard*>(ptr)->setVisible(visible != 0);
}

void QWizard_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QWizard*>(ptr)->QWizard::setVisible(visible != 0);
}

void* QWizard_SideWidget(void* ptr)
{
	return static_cast<QWizard*>(ptr)->sideWidget();
}

void* QWizard_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWizard*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWizard_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWizard*>(ptr)->QWizard::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

char QWizard_TestOption(void* ptr, long long option)
{
	return static_cast<QWizard*>(ptr)->testOption(static_cast<QWizard::WizardOption>(option));
}

char QWizard_ValidateCurrentPage(void* ptr)
{
	return static_cast<QWizard*>(ptr)->validateCurrentPage();
}

char QWizard_ValidateCurrentPageDefault(void* ptr)
{
	return static_cast<QWizard*>(ptr)->QWizard::validateCurrentPage();
}

void QWizard_DestroyQWizard(void* ptr)
{
	static_cast<QWizard*>(ptr)->~QWizard();
}

void QWizard_Accept(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "accept");
}

void QWizard_AcceptDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::accept();
}

void QWizard_CloseEvent(void* ptr, void* e)
{
	static_cast<QWizard*>(ptr)->closeEvent(static_cast<QCloseEvent*>(e));
}

void QWizard_CloseEventDefault(void* ptr, void* e)
{
	static_cast<QWizard*>(ptr)->QWizard::closeEvent(static_cast<QCloseEvent*>(e));
}

void QWizard_ContextMenuEvent(void* ptr, void* e)
{
	static_cast<QWizard*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

void QWizard_ContextMenuEventDefault(void* ptr, void* e)
{
	static_cast<QWizard*>(ptr)->QWizard::contextMenuEvent(static_cast<QContextMenuEvent*>(e));
}

int QWizard_Exec(void* ptr)
{
	int returnArg;
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "exec", Q_RETURN_ARG(int, returnArg));
	return returnArg;
}

int QWizard_ExecDefault(void* ptr)
{
	return static_cast<QWizard*>(ptr)->QWizard::exec();
}

void QWizard_KeyPressEvent(void* ptr, void* e)
{
	static_cast<QWizard*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(e));
}

void QWizard_KeyPressEventDefault(void* ptr, void* e)
{
	static_cast<QWizard*>(ptr)->QWizard::keyPressEvent(static_cast<QKeyEvent*>(e));
}

void* QWizard_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWizard*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWizard_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWizard*>(ptr)->QWizard::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QWizard_Open(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "open");
}

void QWizard_OpenDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::open();
}

void QWizard_Reject(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "reject");
}

void QWizard_RejectDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::reject();
}

void QWizard_ShowEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QWizard_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::showEvent(static_cast<QShowEvent*>(event));
}

void QWizard_ActionEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QWizard_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::actionEvent(static_cast<QActionEvent*>(event));
}

void QWizard_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QWizard_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QWizard_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QWizard_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QWizard_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QWizard_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QWizard_DropEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QWizard_DropEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::dropEvent(static_cast<QDropEvent*>(event));
}

void QWizard_EnterEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QWizard_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::enterEvent(static_cast<QEvent*>(event));
}

void QWizard_FocusInEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QWizard_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QWizard_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QWizard_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QWizard_HideEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QWizard_HideEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::hideEvent(static_cast<QHideEvent*>(event));
}

void QWizard_LeaveEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QWizard_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::leaveEvent(static_cast<QEvent*>(event));
}

void QWizard_MoveEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QWizard_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::moveEvent(static_cast<QMoveEvent*>(event));
}

void QWizard_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QWizard_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QWizard*>(ptr)->QWizard::setEnabled(vbo != 0);
}

void QWizard_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QWizard_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QWizard*>(ptr)->QWizard::setStyleSheet(QString(styleSheet));
}

void QWizard_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QWizard_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QWizard*>(ptr)->QWizard::setWindowModified(vbo != 0);
}

void QWizard_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QWizard_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QWizard*>(ptr)->QWizard::setWindowTitle(QString(vqs));
}

void QWizard_ChangeEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QWizard_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::changeEvent(static_cast<QEvent*>(event));
}

char QWizard_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QWizard_CloseDefault(void* ptr)
{
	return static_cast<QWizard*>(ptr)->QWizard::close();
}

char QWizard_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QWizard*>(ptr)->focusNextPrevChild(next != 0);
}

char QWizard_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QWizard*>(ptr)->QWizard::focusNextPrevChild(next != 0);
}

char QWizard_HasHeightForWidth(void* ptr)
{
	return static_cast<QWizard*>(ptr)->hasHeightForWidth();
}

char QWizard_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QWizard*>(ptr)->QWizard::hasHeightForWidth();
}

int QWizard_HeightForWidth(void* ptr, int w)
{
	return static_cast<QWizard*>(ptr)->heightForWidth(w);
}

int QWizard_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QWizard*>(ptr)->QWizard::heightForWidth(w);
}

void QWizard_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "hide");
}

void QWizard_HideDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::hide();
}

void QWizard_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QWizard_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QWizard_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QWizard*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QWizard_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QWizard*>(ptr)->QWizard::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QWizard_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QWizard_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QWizard_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "lower");
}

void QWizard_LowerDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::lower();
}

void QWizard_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QWizard_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QWizard_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QWizard_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QWizard_MousePressEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QWizard_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QWizard_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QWizard_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QWizard_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "raise");
}

void QWizard_RaiseDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::raise();
}

void QWizard_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "repaint");
}

void QWizard_RepaintDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::repaint();
}

void QWizard_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QWizard_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QWizard*>(ptr)->QWizard::setDisabled(disable != 0);
}

void QWizard_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "setFocus");
}

void QWizard_SetFocus2Default(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::setFocus();
}

void QWizard_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QWizard_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QWizard*>(ptr)->QWizard::setHidden(hidden != 0);
}

void QWizard_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "show");
}

void QWizard_ShowDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::show();
}

void QWizard_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "showFullScreen");
}

void QWizard_ShowFullScreenDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::showFullScreen();
}

void QWizard_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "showMaximized");
}

void QWizard_ShowMaximizedDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::showMaximized();
}

void QWizard_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "showMinimized");
}

void QWizard_ShowMinimizedDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::showMinimized();
}

void QWizard_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "showNormal");
}

void QWizard_ShowNormalDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::showNormal();
}

void QWizard_TabletEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QWizard_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QWizard_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "update");
}

void QWizard_UpdateDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::update();
}

void QWizard_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "updateMicroFocus");
}

void QWizard_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::updateMicroFocus();
}

void QWizard_WheelEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QWizard_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QWizard_TimerEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QWizard_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::timerEvent(static_cast<QTimerEvent*>(event));
}

void QWizard_ChildEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QWizard_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::childEvent(static_cast<QChildEvent*>(event));
}

void QWizard_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QWizard*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QWizard_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QWizard*>(ptr)->QWizard::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QWizard_CustomEvent(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QWizard_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QWizard*>(ptr)->QWizard::customEvent(static_cast<QEvent*>(event));
}

void QWizard_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "deleteLater");
}

void QWizard_DeleteLaterDefault(void* ptr)
{
	static_cast<QWizard*>(ptr)->QWizard::deleteLater();
}

void QWizard_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QWizard*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QWizard_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QWizard*>(ptr)->QWizard::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void* QWizard_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QWizard*>(ptr)->metaObject());
}

void* QWizard_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QWizard*>(ptr)->QWizard::metaObject());
}

class MyQWizardPage: public QWizardPage
{
public:
	MyQWizardPage(QWidget *parent) : QWizardPage(parent) {};
	void cleanupPage() { callbackQWizardPage_CleanupPage(this); };
	void Signal_CompleteChanged() { callbackQWizardPage_CompleteChanged(this); };
	void initializePage() { callbackQWizardPage_InitializePage(this); };
	bool isComplete() const { return callbackQWizardPage_IsComplete(const_cast<MyQWizardPage*>(this)) != 0; };
	int nextId() const { return callbackQWizardPage_NextId(const_cast<MyQWizardPage*>(this)); };
	bool validatePage() { return callbackQWizardPage_ValidatePage(this) != 0; };
	void actionEvent(QActionEvent * event) { callbackQWizardPage_ActionEvent(this, event); };
	void dragEnterEvent(QDragEnterEvent * event) { callbackQWizardPage_DragEnterEvent(this, event); };
	void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWizardPage_DragLeaveEvent(this, event); };
	void dragMoveEvent(QDragMoveEvent * event) { callbackQWizardPage_DragMoveEvent(this, event); };
	void dropEvent(QDropEvent * event) { callbackQWizardPage_DropEvent(this, event); };
	void enterEvent(QEvent * event) { callbackQWizardPage_EnterEvent(this, event); };
	void focusInEvent(QFocusEvent * event) { callbackQWizardPage_FocusInEvent(this, event); };
	void focusOutEvent(QFocusEvent * event) { callbackQWizardPage_FocusOutEvent(this, event); };
	void hideEvent(QHideEvent * event) { callbackQWizardPage_HideEvent(this, event); };
	void leaveEvent(QEvent * event) { callbackQWizardPage_LeaveEvent(this, event); };
	QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWizardPage_MinimumSizeHint(const_cast<MyQWizardPage*>(this))); };
	void moveEvent(QMoveEvent * event) { callbackQWizardPage_MoveEvent(this, event); };
	void paintEvent(QPaintEvent * event) { callbackQWizardPage_PaintEvent(this, event); };
	void setEnabled(bool vbo) { callbackQWizardPage_SetEnabled(this, vbo); };
	void setStyleSheet(const QString & styleSheet) { callbackQWizardPage_SetStyleSheet(this, const_cast<char*>(styleSheet.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void setVisible(bool visible) { callbackQWizardPage_SetVisible(this, visible); };
	void setWindowModified(bool vbo) { callbackQWizardPage_SetWindowModified(this, vbo); };
	void setWindowTitle(const QString & vqs) { callbackQWizardPage_SetWindowTitle(this, const_cast<char*>(vqs.toUtf8().prepend("WHITESPACE").constData()+10)); };
	void showEvent(QShowEvent * event) { callbackQWizardPage_ShowEvent(this, event); };
	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWizardPage_SizeHint(const_cast<MyQWizardPage*>(this))); };
	void changeEvent(QEvent * event) { callbackQWizardPage_ChangeEvent(this, event); };
	bool close() { return callbackQWizardPage_Close(this) != 0; };
	void closeEvent(QCloseEvent * event) { callbackQWizardPage_CloseEvent(this, event); };
	void contextMenuEvent(QContextMenuEvent * event) { callbackQWizardPage_ContextMenuEvent(this, event); };
	bool focusNextPrevChild(bool next) { return callbackQWizardPage_FocusNextPrevChild(this, next) != 0; };
	bool hasHeightForWidth() const { return callbackQWizardPage_HasHeightForWidth(const_cast<MyQWizardPage*>(this)) != 0; };
	int heightForWidth(int w) const { return callbackQWizardPage_HeightForWidth(const_cast<MyQWizardPage*>(this), w); };
	void hide() { callbackQWizardPage_Hide(this); };
	void inputMethodEvent(QInputMethodEvent * event) { callbackQWizardPage_InputMethodEvent(this, event); };
	QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWizardPage_InputMethodQuery(const_cast<MyQWizardPage*>(this), query)); };
	void keyPressEvent(QKeyEvent * event) { callbackQWizardPage_KeyPressEvent(this, event); };
	void keyReleaseEvent(QKeyEvent * event) { callbackQWizardPage_KeyReleaseEvent(this, event); };
	void lower() { callbackQWizardPage_Lower(this); };
	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWizardPage_MouseDoubleClickEvent(this, event); };
	void mouseMoveEvent(QMouseEvent * event) { callbackQWizardPage_MouseMoveEvent(this, event); };
	void mousePressEvent(QMouseEvent * event) { callbackQWizardPage_MousePressEvent(this, event); };
	void mouseReleaseEvent(QMouseEvent * event) { callbackQWizardPage_MouseReleaseEvent(this, event); };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWizardPage_NativeEvent(this, const_cast<char*>(eventType.toHex().prepend("WHITESPACE").constData()+10), message, *result) != 0; };
	void raise() { callbackQWizardPage_Raise(this); };
	void repaint() { callbackQWizardPage_Repaint(this); };
	void resizeEvent(QResizeEvent * event) { callbackQWizardPage_ResizeEvent(this, event); };
	void setDisabled(bool disable) { callbackQWizardPage_SetDisabled(this, disable); };
	void setFocus() { callbackQWizardPage_SetFocus2(this); };
	void setHidden(bool hidden) { callbackQWizardPage_SetHidden(this, hidden); };
	void show() { callbackQWizardPage_Show(this); };
	void showFullScreen() { callbackQWizardPage_ShowFullScreen(this); };
	void showMaximized() { callbackQWizardPage_ShowMaximized(this); };
	void showMinimized() { callbackQWizardPage_ShowMinimized(this); };
	void showNormal() { callbackQWizardPage_ShowNormal(this); };
	void tabletEvent(QTabletEvent * event) { callbackQWizardPage_TabletEvent(this, event); };
	void update() { callbackQWizardPage_Update(this); };
	void updateMicroFocus() { callbackQWizardPage_UpdateMicroFocus(this); };
	void wheelEvent(QWheelEvent * event) { callbackQWizardPage_WheelEvent(this, event); };
	void timerEvent(QTimerEvent * event) { callbackQWizardPage_TimerEvent(this, event); };
	void childEvent(QChildEvent * event) { callbackQWizardPage_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWizardPage_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWizardPage_CustomEvent(this, event); };
	void deleteLater() { callbackQWizardPage_DeleteLater(this); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWizardPage_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWizardPage_EventFilter(this, watched, event) != 0; };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWizardPage_MetaObject(const_cast<MyQWizardPage*>(this))); };
};

void QWizardPage_SetSubTitle(void* ptr, char* subTitle)
{
	static_cast<QWizardPage*>(ptr)->setSubTitle(QString(subTitle));
}

void QWizardPage_SetTitle(void* ptr, char* title)
{
	static_cast<QWizardPage*>(ptr)->setTitle(QString(title));
}

char* QWizardPage_SubTitle(void* ptr)
{
	return const_cast<char*>(static_cast<QWizardPage*>(ptr)->subTitle().toUtf8().prepend("WHITESPACE").constData()+10);
}

char* QWizardPage_Title(void* ptr)
{
	return const_cast<char*>(static_cast<QWizardPage*>(ptr)->title().toUtf8().prepend("WHITESPACE").constData()+10);
}

void* QWizardPage_NewQWizardPage(void* parent)
{
	return new MyQWizardPage(static_cast<QWidget*>(parent));
}

char* QWizardPage_ButtonText(void* ptr, long long which)
{
	return const_cast<char*>(static_cast<QWizardPage*>(ptr)->buttonText(static_cast<QWizard::WizardButton>(which)).toUtf8().prepend("WHITESPACE").constData()+10);
}

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)
{
	QObject::connect(static_cast<QWizardPage*>(ptr), static_cast<void (QWizardPage::*)()>(&QWizardPage::completeChanged), static_cast<MyQWizardPage*>(ptr), static_cast<void (MyQWizardPage::*)()>(&MyQWizardPage::Signal_CompleteChanged));
}

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, char* name)
{
	return new QVariant(static_cast<QWizardPage*>(ptr)->field(QString(name)));
}

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, char* name, void* widget, char* property, char* changedSignal)
{
	static_cast<QWizardPage*>(ptr)->registerField(QString(name), static_cast<QWidget*>(widget), const_cast<const char*>(property), const_cast<const char*>(changedSignal));
}

void QWizardPage_SetButtonText(void* ptr, long long which, char* text)
{
	static_cast<QWizardPage*>(ptr)->setButtonText(static_cast<QWizard::WizardButton>(which), QString(text));
}

void QWizardPage_SetCommitPage(void* ptr, char commitPage)
{
	static_cast<QWizardPage*>(ptr)->setCommitPage(commitPage != 0);
}

void QWizardPage_SetField(void* ptr, char* name, void* value)
{
	static_cast<QWizardPage*>(ptr)->setField(QString(name), *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));
}

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_ActionEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->actionEvent(static_cast<QActionEvent*>(event));
}

void QWizardPage_ActionEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::actionEvent(static_cast<QActionEvent*>(event));
}

void QWizardPage_DragEnterEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QWizardPage_DragEnterEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::dragEnterEvent(static_cast<QDragEnterEvent*>(event));
}

void QWizardPage_DragLeaveEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QWizardPage_DragLeaveEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::dragLeaveEvent(static_cast<QDragLeaveEvent*>(event));
}

void QWizardPage_DragMoveEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QWizardPage_DragMoveEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::dragMoveEvent(static_cast<QDragMoveEvent*>(event));
}

void QWizardPage_DropEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->dropEvent(static_cast<QDropEvent*>(event));
}

void QWizardPage_DropEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::dropEvent(static_cast<QDropEvent*>(event));
}

void QWizardPage_EnterEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->enterEvent(static_cast<QEvent*>(event));
}

void QWizardPage_EnterEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::enterEvent(static_cast<QEvent*>(event));
}

void QWizardPage_FocusInEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(event));
}

void QWizardPage_FocusInEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::focusInEvent(static_cast<QFocusEvent*>(event));
}

void QWizardPage_FocusOutEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QWizardPage_FocusOutEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::focusOutEvent(static_cast<QFocusEvent*>(event));
}

void QWizardPage_HideEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}

void QWizardPage_HideEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::hideEvent(static_cast<QHideEvent*>(event));
}

void QWizardPage_LeaveEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
}

void QWizardPage_LeaveEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::leaveEvent(static_cast<QEvent*>(event));
}

void* QWizardPage_MinimumSizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWizardPage*>(ptr)->minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWizardPage_MinimumSizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWizardPage*>(ptr)->QWizardPage::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QWizardPage_MoveEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}

void QWizardPage_MoveEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::moveEvent(static_cast<QMoveEvent*>(event));
}

void QWizardPage_PaintEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QWizardPage_PaintEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::paintEvent(static_cast<QPaintEvent*>(event));
}

void QWizardPage_SetEnabled(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}

void QWizardPage_SetEnabledDefault(void* ptr, char vbo)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::setEnabled(vbo != 0);
}

void QWizardPage_SetStyleSheet(void* ptr, char* styleSheet)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "setStyleSheet", Q_ARG(QString, QString(styleSheet)));
}

void QWizardPage_SetStyleSheetDefault(void* ptr, char* styleSheet)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::setStyleSheet(QString(styleSheet));
}

void QWizardPage_SetVisible(void* ptr, char visible)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}

void QWizardPage_SetVisibleDefault(void* ptr, char visible)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::setVisible(visible != 0);
}

void QWizardPage_SetWindowModified(void* ptr, char vbo)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}

void QWizardPage_SetWindowModifiedDefault(void* ptr, char vbo)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::setWindowModified(vbo != 0);
}

void QWizardPage_SetWindowTitle(void* ptr, char* vqs)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "setWindowTitle", Q_ARG(QString, QString(vqs)));
}

void QWizardPage_SetWindowTitleDefault(void* ptr, char* vqs)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::setWindowTitle(QString(vqs));
}

void QWizardPage_ShowEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}

void QWizardPage_ShowEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::showEvent(static_cast<QShowEvent*>(event));
}

void* QWizardPage_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWizardPage*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QWizardPage_SizeHintDefault(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QWizardPage*>(ptr)->QWizardPage::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QWizardPage_ChangeEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->changeEvent(static_cast<QEvent*>(event));
}

void QWizardPage_ChangeEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::changeEvent(static_cast<QEvent*>(event));
}

char QWizardPage_Close(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QWizardPage_CloseDefault(void* ptr)
{
	return static_cast<QWizardPage*>(ptr)->QWizardPage::close();
}

void QWizardPage_CloseEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->closeEvent(static_cast<QCloseEvent*>(event));
}

void QWizardPage_CloseEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::closeEvent(static_cast<QCloseEvent*>(event));
}

void QWizardPage_ContextMenuEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

void QWizardPage_ContextMenuEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::contextMenuEvent(static_cast<QContextMenuEvent*>(event));
}

char QWizardPage_FocusNextPrevChild(void* ptr, char next)
{
	return static_cast<QWizardPage*>(ptr)->focusNextPrevChild(next != 0);
}

char QWizardPage_FocusNextPrevChildDefault(void* ptr, char next)
{
	return static_cast<QWizardPage*>(ptr)->QWizardPage::focusNextPrevChild(next != 0);
}

char QWizardPage_HasHeightForWidth(void* ptr)
{
	return static_cast<QWizardPage*>(ptr)->hasHeightForWidth();
}

char QWizardPage_HasHeightForWidthDefault(void* ptr)
{
	return static_cast<QWizardPage*>(ptr)->QWizardPage::hasHeightForWidth();
}

int QWizardPage_HeightForWidth(void* ptr, int w)
{
	return static_cast<QWizardPage*>(ptr)->heightForWidth(w);
}

int QWizardPage_HeightForWidthDefault(void* ptr, int w)
{
	return static_cast<QWizardPage*>(ptr)->QWizardPage::heightForWidth(w);
}

void QWizardPage_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "hide");
}

void QWizardPage_HideDefault(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::hide();
}

void QWizardPage_InputMethodEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void QWizardPage_InputMethodEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::inputMethodEvent(static_cast<QInputMethodEvent*>(event));
}

void* QWizardPage_InputMethodQuery(void* ptr, long long query)
{
	return new QVariant(static_cast<QWizardPage*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void* QWizardPage_InputMethodQueryDefault(void* ptr, long long query)
{
	return new QVariant(static_cast<QWizardPage*>(ptr)->QWizardPage::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}

void QWizardPage_KeyPressEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QWizardPage_KeyPressEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::keyPressEvent(static_cast<QKeyEvent*>(event));
}

void QWizardPage_KeyReleaseEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QWizardPage_KeyReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::keyReleaseEvent(static_cast<QKeyEvent*>(event));
}

void QWizardPage_Lower(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "lower");
}

void QWizardPage_LowerDefault(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::lower();
}

void QWizardPage_MouseDoubleClickEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QWizardPage_MouseDoubleClickEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::mouseDoubleClickEvent(static_cast<QMouseEvent*>(event));
}

void QWizardPage_MouseMoveEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QWizardPage_MouseMoveEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::mouseMoveEvent(static_cast<QMouseEvent*>(event));
}

void QWizardPage_MousePressEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QWizardPage_MousePressEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::mousePressEvent(static_cast<QMouseEvent*>(event));
}

void QWizardPage_MouseReleaseEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

void QWizardPage_MouseReleaseEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::mouseReleaseEvent(static_cast<QMouseEvent*>(event));
}

char QWizardPage_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QWizardPage*>(ptr)->nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

char QWizardPage_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
	return static_cast<QWizardPage*>(ptr)->QWizardPage::nativeEvent(QByteArray::fromHex(QString(eventType).toUtf8()), message, &result);
}

void QWizardPage_Raise(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "raise");
}

void QWizardPage_RaiseDefault(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::raise();
}

void QWizardPage_Repaint(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "repaint");
}

void QWizardPage_RepaintDefault(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::repaint();
}

void QWizardPage_ResizeEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}

void QWizardPage_ResizeEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::resizeEvent(static_cast<QResizeEvent*>(event));
}

void QWizardPage_SetDisabled(void* ptr, char disable)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}

void QWizardPage_SetDisabledDefault(void* ptr, char disable)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::setDisabled(disable != 0);
}

void QWizardPage_SetFocus2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "setFocus");
}

void QWizardPage_SetFocus2Default(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::setFocus();
}

void QWizardPage_SetHidden(void* ptr, char hidden)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}

void QWizardPage_SetHiddenDefault(void* ptr, char hidden)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::setHidden(hidden != 0);
}

void QWizardPage_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "show");
}

void QWizardPage_ShowDefault(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::show();
}

void QWizardPage_ShowFullScreen(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "showFullScreen");
}

void QWizardPage_ShowFullScreenDefault(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::showFullScreen();
}

void QWizardPage_ShowMaximized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "showMaximized");
}

void QWizardPage_ShowMaximizedDefault(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::showMaximized();
}

void QWizardPage_ShowMinimized(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "showMinimized");
}

void QWizardPage_ShowMinimizedDefault(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::showMinimized();
}

void QWizardPage_ShowNormal(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "showNormal");
}

void QWizardPage_ShowNormalDefault(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::showNormal();
}

void QWizardPage_TabletEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(event));
}

void QWizardPage_TabletEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::tabletEvent(static_cast<QTabletEvent*>(event));
}

void QWizardPage_Update(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "update");
}

void QWizardPage_UpdateDefault(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::update();
}

void QWizardPage_UpdateMicroFocus(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "updateMicroFocus");
}

void QWizardPage_UpdateMicroFocusDefault(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::updateMicroFocus();
}

void QWizardPage_WheelEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(event));
}

void QWizardPage_WheelEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::wheelEvent(static_cast<QWheelEvent*>(event));
}

void QWizardPage_TimerEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QWizardPage_TimerEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::timerEvent(static_cast<QTimerEvent*>(event));
}

void QWizardPage_ChildEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QWizardPage_ChildEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::childEvent(static_cast<QChildEvent*>(event));
}

void QWizardPage_ConnectNotify(void* ptr, void* sign)
{
	static_cast<QWizardPage*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QWizardPage_ConnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QWizardPage_CustomEvent(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QWizardPage_CustomEventDefault(void* ptr, void* event)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::customEvent(static_cast<QEvent*>(event));
}

void QWizardPage_DeleteLater(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "deleteLater");
}

void QWizardPage_DeleteLaterDefault(void* ptr)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::deleteLater();
}

void QWizardPage_DisconnectNotify(void* ptr, void* sign)
{
	static_cast<QWizardPage*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QWizardPage_DisconnectNotifyDefault(void* ptr, void* sign)
{
	static_cast<QWizardPage*>(ptr)->QWizardPage::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

char QWizardPage_EventFilter(void* ptr, void* watched, void* event)
{
	return static_cast<QWizardPage*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

char QWizardPage_EventFilterDefault(void* ptr, void* watched, void* event)
{
	return static_cast<QWizardPage*>(ptr)->QWizardPage::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}

void* QWizardPage_MetaObject(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QWizardPage*>(ptr)->metaObject());
}

void* QWizardPage_MetaObjectDefault(void* ptr)
{
	return const_cast<QMetaObject*>(static_cast<QWizardPage*>(ptr)->QWizardPage::metaObject());
}