lib/cutego
1
0
Fork 0
mirror of https://github.com/bluszcz/cutego.git synced 2024-09-29 05:35:16 +03:00
Code Issues Projects Releases Packages Wiki Activity
cutego/widgets/widgets.cpp
therecipe 54bd9aaf76 minor cleanup and support for iOS
2016-05-15 22:07:05 +02:00

98111 lines
3.6 MiB
Executable file
Raw Blame History

#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, this->objectName().toUtf8().data(), vbo); };
void setIconSize(const QSize & size) { callbackQAbstractButton_SetIconSize(this, this->objectName().toUtf8().data(), new QSize(static_cast<QSize>(size).width(), static_cast<QSize>(size).height())); };
void toggle() { callbackQAbstractButton_Toggle(this, this->objectName().toUtf8().data()); };
void animateClick(int msec) { callbackQAbstractButton_AnimateClick(this, this->objectName().toUtf8().data(), msec); };
void changeEvent(QEvent * e) { callbackQAbstractButton_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void checkStateSet() { callbackQAbstractButton_CheckStateSet(this, this->objectName().toUtf8().data()); };
void click() { callbackQAbstractButton_Click(this, this->objectName().toUtf8().data()); };
void Signal_Clicked(bool checked) { callbackQAbstractButton_Clicked(this, this->objectName().toUtf8().data(), checked); };
void focusInEvent(QFocusEvent * e) { callbackQAbstractButton_FocusInEvent(this, this->objectName().toUtf8().data(), e); };
void focusOutEvent(QFocusEvent * e) { callbackQAbstractButton_FocusOutEvent(this, this->objectName().toUtf8().data(), e); };
bool hitButton(const QPoint & pos) const { return callbackQAbstractButton_HitButton(const_cast<MyQAbstractButton*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(pos).x(), static_cast<QPoint>(pos).y())) != 0; };
void keyPressEvent(QKeyEvent * e) { callbackQAbstractButton_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void keyReleaseEvent(QKeyEvent * e) { callbackQAbstractButton_KeyReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void mouseMoveEvent(QMouseEvent * e) { callbackQAbstractButton_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQAbstractButton_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQAbstractButton_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void nextCheckState() { callbackQAbstractButton_NextCheckState(this, this->objectName().toUtf8().data()); };
void paintEvent(QPaintEvent * e) { callbackQAbstractButton_PaintEvent(this, this->objectName().toUtf8().data(), e); };
void Signal_Pressed() { callbackQAbstractButton_Pressed(this, this->objectName().toUtf8().data()); };
void Signal_Released() { callbackQAbstractButton_Released(this, this->objectName().toUtf8().data()); };
void Signal_Toggled(bool checked) { callbackQAbstractButton_Toggled(this, this->objectName().toUtf8().data(), checked); };
void actionEvent(QActionEvent * event) { callbackQAbstractButton_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQAbstractButton_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQAbstractButton_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQAbstractButton_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQAbstractButton_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQAbstractButton_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQAbstractButton_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQAbstractButton_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQAbstractButton_MinimumSizeHint(const_cast<MyQAbstractButton*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQAbstractButton_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQAbstractButton_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQAbstractButton_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQAbstractButton_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQAbstractButton_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQAbstractButton_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQAbstractButton_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQAbstractButton_SizeHint(const_cast<MyQAbstractButton*>(this), this->objectName().toUtf8().data())); };
bool close() { return callbackQAbstractButton_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQAbstractButton_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQAbstractButton_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQAbstractButton_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQAbstractButton_HasHeightForWidth(const_cast<MyQAbstractButton*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQAbstractButton_HeightForWidth(const_cast<MyQAbstractButton*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQAbstractButton_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQAbstractButton_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQAbstractButton_InputMethodQuery(const_cast<MyQAbstractButton*>(this), this->objectName().toUtf8().data(), query)); };
void lower() { callbackQAbstractButton_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQAbstractButton_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQAbstractButton_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQAbstractButton_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQAbstractButton_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQAbstractButton_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQAbstractButton_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQAbstractButton_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQAbstractButton_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQAbstractButton_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQAbstractButton_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQAbstractButton_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQAbstractButton_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQAbstractButton_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQAbstractButton_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQAbstractButton_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQAbstractButton_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQAbstractButton_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQAbstractButton_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQAbstractButton_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQAbstractButton_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQAbstractButton_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractButton_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractButton_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractButton_MetaObject(const_cast<MyQAbstractButton*>(this), this->objectName().toUtf8().data())); };
};
int QAbstractButton_AutoExclusive(void* ptr)
{
return static_cast<QAbstractButton*>(ptr)->autoExclusive();
}
int 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 new QSize(static_cast<QSize>(static_cast<QAbstractButton*>(ptr)->iconSize()).width(), static_cast<QSize>(static_cast<QAbstractButton*>(ptr)->iconSize()).height());
}
int QAbstractButton_IsCheckable(void* ptr)
{
return static_cast<QAbstractButton*>(ptr)->isCheckable();
}
int QAbstractButton_IsChecked(void* ptr)
{
return static_cast<QAbstractButton*>(ptr)->isChecked();
}
int QAbstractButton_IsDown(void* ptr)
{
return static_cast<QAbstractButton*>(ptr)->isDown();
}
void QAbstractButton_SetAutoExclusive(void* ptr, int vbo)
{
static_cast<QAbstractButton*>(ptr)->setAutoExclusive(vbo != 0);
}
void QAbstractButton_SetAutoRepeat(void* ptr, int 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, int vbo)
{
static_cast<QAbstractButton*>(ptr)->setCheckable(vbo != 0);
}
void QAbstractButton_SetChecked(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}
void QAbstractButton_SetDown(void* ptr, int 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 static_cast<QAbstractButton*>(ptr)->text().toUtf8().data();
}
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, int checked)
{
static_cast<QAbstractButton*>(ptr)->clicked(checked != 0);
}
int 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();
}
int QAbstractButton_HitButton(void* ptr, void* pos)
{
return static_cast<QAbstractButton*>(ptr)->hitButton(*static_cast<QPoint*>(pos));
}
int 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, int 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 new QSize(static_cast<QSize>(static_cast<QAbstractButton*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractButton*>(ptr)->minimumSizeHint()).height());
}
void* QAbstractButton_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractButton*>(ptr)->QAbstractButton::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractButton*>(ptr)->QAbstractButton::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QAbstractButton_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QAbstractButton_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QAbstractButton*>(ptr)->QAbstractButton::setVisible(visible != 0);
}
void QAbstractButton_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QAbstractButton_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QAbstractButton*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QAbstractButton*>(ptr)->sizeHint()).height());
}
void* QAbstractButton_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractButton*>(ptr)->QAbstractButton::sizeHint()).width(), static_cast<QSize>(static_cast<QAbstractButton*>(ptr)->QAbstractButton::sizeHint()).height());
}
int QAbstractButton_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QAbstractButton_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QAbstractButton*>(ptr)->focusNextPrevChild(next != 0);
}
int QAbstractButton_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QAbstractButton*>(ptr)->QAbstractButton::focusNextPrevChild(next != 0);
}
int QAbstractButton_HasHeightForWidth(void* ptr)
{
return static_cast<QAbstractButton*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QAbstractButton*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QAbstractButton_InputMethodQueryDefault(void* ptr, int 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));
}
int QAbstractButton_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QAbstractButton*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QAbstractButton_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QAbstractButton*>(ptr)->QAbstractButton::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QAbstractButton_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QAbstractButton*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QAbstractButton_SetHiddenDefault(void* ptr, int 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));
}
int QAbstractButton_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QAbstractButton*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQAbstractGraphicsShapeItem(QGraphicsItem *parent) : QAbstractGraphicsShapeItem(parent) {};
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQAbstractGraphicsShapeItem_IsObscuredBy(const_cast<MyQAbstractGraphicsShapeItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQAbstractGraphicsShapeItem_OpaqueArea(const_cast<MyQAbstractGraphicsShapeItem*>(this), this->objectNameAbs().toUtf8().data())); };
void advance(int phase) { callbackQAbstractGraphicsShapeItem_Advance(this, this->objectNameAbs().toUtf8().data(), phase); };
QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQAbstractGraphicsShapeItem_BoundingRect(const_cast<MyQAbstractGraphicsShapeItem*>(this), this->objectNameAbs().toUtf8().data())); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQAbstractGraphicsShapeItem_CollidesWithItem(const_cast<MyQAbstractGraphicsShapeItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQAbstractGraphicsShapeItem_CollidesWithPath(const_cast<MyQAbstractGraphicsShapeItem*>(this), this->objectNameAbs().toUtf8().data(), new QPainterPath(path), mode) != 0; };
bool contains(const QPointF & point) const { return callbackQAbstractGraphicsShapeItem_Contains(const_cast<MyQAbstractGraphicsShapeItem*>(this), this->objectNameAbs().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQAbstractGraphicsShapeItem_ContextMenuEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQAbstractGraphicsShapeItem_DragEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQAbstractGraphicsShapeItem_DragLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQAbstractGraphicsShapeItem_DragMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQAbstractGraphicsShapeItem_DropEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQAbstractGraphicsShapeItem_FocusInEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQAbstractGraphicsShapeItem_FocusOutEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQAbstractGraphicsShapeItem_HoverEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQAbstractGraphicsShapeItem_HoverLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQAbstractGraphicsShapeItem_HoverMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQAbstractGraphicsShapeItem_InputMethodEvent(this, this->objectNameAbs().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQAbstractGraphicsShapeItem_InputMethodQuery(const_cast<MyQAbstractGraphicsShapeItem*>(this), this->objectNameAbs().toUtf8().data(), query)); };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQAbstractGraphicsShapeItem_ItemChange(this, this->objectNameAbs().toUtf8().data(), change, new QVariant(value))); };
void keyPressEvent(QKeyEvent * event) { callbackQAbstractGraphicsShapeItem_KeyPressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQAbstractGraphicsShapeItem_KeyReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQAbstractGraphicsShapeItem_MouseDoubleClickEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQAbstractGraphicsShapeItem_MouseMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQAbstractGraphicsShapeItem_MousePressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQAbstractGraphicsShapeItem_MouseReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQAbstractGraphicsShapeItem_Paint(this, this->objectNameAbs().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
bool sceneEvent(QEvent * event) { return callbackQAbstractGraphicsShapeItem_SceneEvent(this, this->objectNameAbs().toUtf8().data(), event) != 0; };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQAbstractGraphicsShapeItem_SceneEventFilter(this, this->objectNameAbs().toUtf8().data(), watched, event) != 0; };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQAbstractGraphicsShapeItem_Shape(const_cast<MyQAbstractGraphicsShapeItem*>(this), this->objectNameAbs().toUtf8().data())); };
int type() const { return callbackQAbstractGraphicsShapeItem_Type(const_cast<MyQAbstractGraphicsShapeItem*>(this), this->objectNameAbs().toUtf8().data()); };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQAbstractGraphicsShapeItem_WheelEvent(this, this->objectNameAbs().toUtf8().data(), 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());
}
int QAbstractGraphicsShapeItem_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QAbstractGraphicsShapeItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int 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();
}
char* QAbstractGraphicsShapeItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQAbstractGraphicsShapeItem*>(static_cast<QAbstractGraphicsShapeItem*>(ptr))) {
return static_cast<MyQAbstractGraphicsShapeItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QAbstractGraphicsShapeItem_BASE").toUtf8().data();
}
void QAbstractGraphicsShapeItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQAbstractGraphicsShapeItem*>(static_cast<QAbstractGraphicsShapeItem*>(ptr))) {
static_cast<MyQAbstractGraphicsShapeItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
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 new QRectF(static_cast<QRectF>(static_cast<QAbstractGraphicsShapeItem*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QAbstractGraphicsShapeItem*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QAbstractGraphicsShapeItem*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QAbstractGraphicsShapeItem*>(ptr)->boundingRect()).height());
}
int QAbstractGraphicsShapeItem_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QAbstractGraphicsShapeItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QAbstractGraphicsShapeItem_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QAbstractGraphicsShapeItem_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QAbstractGraphicsShapeItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QAbstractGraphicsShapeItem_CollidesWithPathDefault(void* ptr, void* path, int mode)
{
return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QAbstractGraphicsShapeItem_Contains(void* ptr, void* point)
{
return static_cast<QAbstractGraphicsShapeItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int 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, int query)
{
return new QVariant(static_cast<QAbstractGraphicsShapeItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QAbstractGraphicsShapeItem_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QAbstractGraphicsShapeItem_ItemChange(void* ptr, int 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, int 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));
}
int QAbstractGraphicsShapeItem_SceneEvent(void* ptr, void* event)
{
return static_cast<QAbstractGraphicsShapeItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int QAbstractGraphicsShapeItem_SceneEventDefault(void* ptr, void* event)
{
return static_cast<QAbstractGraphicsShapeItem*>(ptr)->QAbstractGraphicsShapeItem::sceneEvent(static_cast<QEvent*>(event));
}
int QAbstractGraphicsShapeItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QAbstractGraphicsShapeItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), editor, hint); };
void Signal_CommitData(QWidget * editor) { callbackQAbstractItemDelegate_CommitData(this, this->objectName().toUtf8().data(), editor); };
QWidget * createEditor(QWidget * parent, const QStyleOptionViewItem & option, const QModelIndex & index) const { return static_cast<QWidget*>(callbackQAbstractItemDelegate_CreateEditor(const_cast<MyQAbstractItemDelegate*>(this), this->objectName().toUtf8().data(), parent, new QStyleOptionViewItem(option), new QModelIndex(index))); };
void destroyEditor(QWidget * editor, const QModelIndex & index) const { callbackQAbstractItemDelegate_DestroyEditor(const_cast<MyQAbstractItemDelegate*>(this), this->objectName().toUtf8().data(), editor, new QModelIndex(index)); };
bool editorEvent(QEvent * event, QAbstractItemModel * model, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQAbstractItemDelegate_EditorEvent(this, this->objectName().toUtf8().data(), event, model, new QStyleOptionViewItem(option), new QModelIndex(index)) != 0; };
bool helpEvent(QHelpEvent * event, QAbstractItemView * view, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQAbstractItemDelegate_HelpEvent(this, this->objectName().toUtf8().data(), event, view, new QStyleOptionViewItem(option), new QModelIndex(index)) != 0; };
void paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQAbstractItemDelegate_Paint(const_cast<MyQAbstractItemDelegate*>(this), this->objectName().toUtf8().data(), painter, new QStyleOptionViewItem(option), new QModelIndex(index)); };
void setEditorData(QWidget * editor, const QModelIndex & index) const { callbackQAbstractItemDelegate_SetEditorData(const_cast<MyQAbstractItemDelegate*>(this), this->objectName().toUtf8().data(), editor, new QModelIndex(index)); };
void setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex & index) const { callbackQAbstractItemDelegate_SetModelData(const_cast<MyQAbstractItemDelegate*>(this), this->objectName().toUtf8().data(), editor, model, new QModelIndex(index)); };
QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex & index) const { return *static_cast<QSize*>(callbackQAbstractItemDelegate_SizeHint(const_cast<MyQAbstractItemDelegate*>(this), this->objectName().toUtf8().data(), new QStyleOptionViewItem(option), new QModelIndex(index))); };
void Signal_SizeHintChanged(const QModelIndex & index) { callbackQAbstractItemDelegate_SizeHintChanged(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void updateEditorGeometry(QWidget * editor, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQAbstractItemDelegate_UpdateEditorGeometry(const_cast<MyQAbstractItemDelegate*>(this), this->objectName().toUtf8().data(), editor, new QStyleOptionViewItem(option), new QModelIndex(index)); };
void timerEvent(QTimerEvent * event) { callbackQAbstractItemDelegate_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQAbstractItemDelegate_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQAbstractItemDelegate_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQAbstractItemDelegate_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQAbstractItemDelegate_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractItemDelegate_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQAbstractItemDelegate_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractItemDelegate_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractItemDelegate_MetaObject(const_cast<MyQAbstractItemDelegate*>(this), this->objectName().toUtf8().data())); };
};
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, int 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));
}
int 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));
}
int 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));
}
int 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));
}
int 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 new QSize(static_cast<QSize>(static_cast<QAbstractItemDelegate*>(ptr)->sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index))).width(), static_cast<QSize>(static_cast<QAbstractItemDelegate*>(ptr)->sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index))).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_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));
}
int QAbstractItemDelegate_Event(void* ptr, void* e)
{
return static_cast<QAbstractItemDelegate*>(ptr)->event(static_cast<QEvent*>(e));
}
int QAbstractItemDelegate_EventDefault(void* ptr, void* e)
{
return static_cast<QAbstractItemDelegate*>(ptr)->QAbstractItemDelegate::event(static_cast<QEvent*>(e));
}
int QAbstractItemDelegate_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QAbstractItemDelegate*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), event); };
bool viewportEvent(QEvent * event) { return callbackQAbstractItemView_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
void Signal_Activated(const QModelIndex & index) { callbackQAbstractItemView_Activated(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void clearSelection() { callbackQAbstractItemView_ClearSelection(this, this->objectName().toUtf8().data()); };
void Signal_Clicked(const QModelIndex & index) { callbackQAbstractItemView_Clicked(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQAbstractItemView_CloseEditor(this, this->objectName().toUtf8().data(), editor, hint); };
void commitData(QWidget * editor) { callbackQAbstractItemView_CommitData(this, this->objectName().toUtf8().data(), editor); };
void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQAbstractItemView_CurrentChanged(this, this->objectName().toUtf8().data(), new QModelIndex(current), new QModelIndex(previous)); };
void Signal_DoubleClicked(const QModelIndex & index) { callbackQAbstractItemView_DoubleClicked(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQAbstractItemView_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQAbstractItemView_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQAbstractItemView_DropEvent(this, this->objectName().toUtf8().data(), event); };
void edit(const QModelIndex & index) { callbackQAbstractItemView_Edit(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQAbstractItemView_Edit2(this, this->objectName().toUtf8().data(), new QModelIndex(index), trigger, event) != 0; };
void editorDestroyed(QObject * editor) { callbackQAbstractItemView_EditorDestroyed(this, this->objectName().toUtf8().data(), editor); };
void Signal_Entered(const QModelIndex & index) { callbackQAbstractItemView_Entered(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void focusInEvent(QFocusEvent * event) { callbackQAbstractItemView_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQAbstractItemView_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * event) { callbackQAbstractItemView_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
int horizontalOffset() const { return callbackQAbstractItemView_HorizontalOffset(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data()); };
void Signal_IconSizeChanged(const QSize & size) { callbackQAbstractItemView_IconSizeChanged(this, this->objectName().toUtf8().data(), new QSize(static_cast<QSize>(size).width(), static_cast<QSize>(size).height())); };
QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQAbstractItemView_IndexAt(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(point).x(), static_cast<QPoint>(point).y()))); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQAbstractItemView_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQAbstractItemView_InputMethodQuery(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data(), query)); };
bool isIndexHidden(const QModelIndex & index) const { return callbackQAbstractItemView_IsIndexHidden(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index)) != 0; };
void keyPressEvent(QKeyEvent * event) { callbackQAbstractItemView_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyboardSearch(const QString & search) { callbackQAbstractItemView_KeyboardSearch(this, this->objectName().toUtf8().data(), search.toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQAbstractItemView_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQAbstractItemView_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQAbstractItemView_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQAbstractItemView_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQAbstractItemView_MoveCursor(this, this->objectName().toUtf8().data(), cursorAction, modifiers)); };
void Signal_Pressed(const QModelIndex & index) { callbackQAbstractItemView_Pressed(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void reset() { callbackQAbstractItemView_Reset(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQAbstractItemView_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQAbstractItemView_RowsAboutToBeRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemView_RowsInserted(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQAbstractItemView_ScrollTo(this, this->objectName().toUtf8().data(), new QModelIndex(index), hint); };
void scrollToBottom() { callbackQAbstractItemView_ScrollToBottom(this, this->objectName().toUtf8().data()); };
void scrollToTop() { callbackQAbstractItemView_ScrollToTop(this, this->objectName().toUtf8().data()); };
void selectAll() { callbackQAbstractItemView_SelectAll(this, this->objectName().toUtf8().data()); };
void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQAbstractItemView_SelectionChanged(this, this->objectName().toUtf8().data(), new QItemSelection(selected), new QItemSelection(deselected)); };
QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQAbstractItemView_SelectionCommand(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index), const_cast<QEvent*>(event))); };
void setCurrentIndex(const QModelIndex & index) { callbackQAbstractItemView_SetCurrentIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setModel(QAbstractItemModel * model) { callbackQAbstractItemView_SetModel(this, this->objectName().toUtf8().data(), model); };
void setRootIndex(const QModelIndex & index) { callbackQAbstractItemView_SetRootIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags flags) { callbackQAbstractItemView_SetSelection(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), flags); };
void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQAbstractItemView_SetSelectionModel(this, this->objectName().toUtf8().data(), selectionModel); };
int sizeHintForColumn(int column) const { return callbackQAbstractItemView_SizeHintForColumn(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data(), column); };
int sizeHintForRow(int row) const { return callbackQAbstractItemView_SizeHintForRow(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data(), row); };
void startDrag(Qt::DropActions supportedActions) { callbackQAbstractItemView_StartDrag(this, this->objectName().toUtf8().data(), supportedActions); };
void update(const QModelIndex & index) { callbackQAbstractItemView_Update(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void updateGeometries() { callbackQAbstractItemView_UpdateGeometries(this, this->objectName().toUtf8().data()); };
int verticalOffset() const { return callbackQAbstractItemView_VerticalOffset(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data()); };
QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQAbstractItemView_ViewOptions(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data())); };
void Signal_ViewportEntered() { callbackQAbstractItemView_ViewportEntered(this, this->objectName().toUtf8().data()); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractItemView_ViewportSizeHint(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data())); };
QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQAbstractItemView_VisualRect(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index))); };
QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQAbstractItemView_VisualRegionForSelection(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data(), new QItemSelection(selection))); };
void paintEvent(QPaintEvent * event) { callbackQAbstractItemView_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQAbstractItemView_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQAbstractItemView_MinimumSizeHint(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data())); };
void scrollContentsBy(int dx, int dy) { callbackQAbstractItemView_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void setupViewport(QWidget * viewport) { callbackQAbstractItemView_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQAbstractItemView_SizeHint(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data())); };
void wheelEvent(QWheelEvent * e) { callbackQAbstractItemView_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void changeEvent(QEvent * ev) { callbackQAbstractItemView_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQAbstractItemView_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQAbstractItemView_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQAbstractItemView_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQAbstractItemView_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQAbstractItemView_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQAbstractItemView_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQAbstractItemView_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQAbstractItemView_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQAbstractItemView_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQAbstractItemView_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQAbstractItemView_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQAbstractItemView_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQAbstractItemView_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQAbstractItemView_HasHeightForWidth(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQAbstractItemView_HeightForWidth(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQAbstractItemView_Hide(this, this->objectName().toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * event) { callbackQAbstractItemView_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQAbstractItemView_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQAbstractItemView_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQAbstractItemView_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQAbstractItemView_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQAbstractItemView_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQAbstractItemView_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQAbstractItemView_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQAbstractItemView_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQAbstractItemView_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQAbstractItemView_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQAbstractItemView_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQAbstractItemView_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQAbstractItemView_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void updateMicroFocus() { callbackQAbstractItemView_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQAbstractItemView_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQAbstractItemView_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQAbstractItemView_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQAbstractItemView_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractItemView_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractItemView_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractItemView_MetaObject(const_cast<MyQAbstractItemView*>(this), this->objectName().toUtf8().data())); };
};
int QAbstractItemView_AlternatingRowColors(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->alternatingRowColors();
}
int QAbstractItemView_AutoScrollMargin(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->autoScrollMargin();
}
int QAbstractItemView_DefaultDropAction(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->defaultDropAction();
}
int QAbstractItemView_DragDropMode(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->dragDropMode();
}
int QAbstractItemView_DragDropOverwriteMode(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->dragDropOverwriteMode();
}
int 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));
}
int QAbstractItemView_EditTriggers(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->editTriggers();
}
int QAbstractItemView_HasAutoScroll(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->hasAutoScroll();
}
int QAbstractItemView_HorizontalScrollMode(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->horizontalScrollMode();
}
void* QAbstractItemView_IconSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->iconSize()).width(), static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->iconSize()).height());
}
int QAbstractItemView_SelectionBehavior(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->selectionBehavior();
}
int QAbstractItemView_SelectionMode(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->selectionMode();
}
void QAbstractItemView_SetAlternatingRowColors(void* ptr, int enable)
{
static_cast<QAbstractItemView*>(ptr)->setAlternatingRowColors(enable != 0);
}
void QAbstractItemView_SetAutoScroll(void* ptr, int 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, int dropAction)
{
static_cast<QAbstractItemView*>(ptr)->setDefaultDropAction(static_cast<Qt::DropAction>(dropAction));
}
void QAbstractItemView_SetDragDropMode(void* ptr, int behavior)
{
static_cast<QAbstractItemView*>(ptr)->setDragDropMode(static_cast<QAbstractItemView::DragDropMode>(behavior));
}
void QAbstractItemView_SetDragDropOverwriteMode(void* ptr, int overwrite)
{
static_cast<QAbstractItemView*>(ptr)->setDragDropOverwriteMode(overwrite != 0);
}
void QAbstractItemView_SetDragEnabled(void* ptr, int enable)
{
static_cast<QAbstractItemView*>(ptr)->setDragEnabled(enable != 0);
}
void QAbstractItemView_SetDropIndicatorShown(void* ptr, int enable)
{
static_cast<QAbstractItemView*>(ptr)->setDropIndicatorShown(enable != 0);
}
void QAbstractItemView_SetEditTriggers(void* ptr, int triggers)
{
static_cast<QAbstractItemView*>(ptr)->setEditTriggers(static_cast<QAbstractItemView::EditTrigger>(triggers));
}
void QAbstractItemView_SetHorizontalScrollMode(void* ptr, int 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, int behavior)
{
static_cast<QAbstractItemView*>(ptr)->setSelectionBehavior(static_cast<QAbstractItemView::SelectionBehavior>(behavior));
}
void QAbstractItemView_SetSelectionMode(void* ptr, int mode)
{
static_cast<QAbstractItemView*>(ptr)->setSelectionMode(static_cast<QAbstractItemView::SelectionMode>(mode));
}
void QAbstractItemView_SetTabKeyNavigation(void* ptr, int enable)
{
static_cast<QAbstractItemView*>(ptr)->setTabKeyNavigation(enable != 0);
}
void QAbstractItemView_SetTextElideMode(void* ptr, int mode)
{
static_cast<QAbstractItemView*>(ptr)->setTextElideMode(static_cast<Qt::TextElideMode>(mode));
}
void QAbstractItemView_SetVerticalScrollMode(void* ptr, int mode)
{
static_cast<QAbstractItemView*>(ptr)->setVerticalScrollMode(static_cast<QAbstractItemView::ScrollMode>(mode));
}
int QAbstractItemView_ShowDropIndicator(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->showDropIndicator();
}
int QAbstractItemView_TabKeyNavigation(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->tabKeyNavigation();
}
int QAbstractItemView_TextElideMode(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->textElideMode();
}
int QAbstractItemView_VerticalScrollMode(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->verticalScrollMode();
}
int QAbstractItemView_ViewportEvent(void* ptr, void* event)
{
return static_cast<QAbstractItemView*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int 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, int 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, int 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 new QPoint(static_cast<QPoint>(static_cast<QAbstractItemView*>(ptr)->dirtyRegionOffset()).x(), static_cast<QPoint>(static_cast<QAbstractItemView*>(ptr)->dirtyRegionOffset()).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));
}
int 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)));
}
int QAbstractItemView_Edit2(void* ptr, void* index, int trigger, void* event)
{
return static_cast<QAbstractItemView*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}
int QAbstractItemView_Edit2Default(void* ptr, void* index, int 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));
}
int 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));
}
int QAbstractItemView_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QAbstractItemView*>(ptr)->focusNextPrevChild(next != 0);
}
int QAbstractItemView_FocusNextPrevChildDefault(void* ptr, int 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, int query)
{
return new QVariant(static_cast<QAbstractItemView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QAbstractItemView_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
int 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, int cursorAction, int 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, int 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));
}
int QAbstractItemView_SelectionCommand(void* ptr, void* index, void* event)
{
return static_cast<QAbstractItemView*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}
int 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, int 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, int 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 new QSize(static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->sizeHintForIndex(*static_cast<QModelIndex*>(index))).width(), static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->sizeHintForIndex(*static_cast<QModelIndex*>(index))).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, int supportedActions)
{
static_cast<QAbstractItemView*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}
void QAbstractItemView_StartDragDefault(void* ptr, int supportedActions)
{
static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::startDrag(static_cast<Qt::DropAction>(supportedActions));
}
int 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 new QSize(static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->viewportSizeHint()).height());
}
void* QAbstractItemView_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::viewportSizeHint()).height());
}
void* QAbstractItemView_VisualRect(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QAbstractItemView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QAbstractItemView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QAbstractItemView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QAbstractItemView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).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 new QSize(static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->minimumSizeHint()).height());
}
void* QAbstractItemView_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->sizeHint()).height());
}
void* QAbstractItemView_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::sizeHint()).width(), static_cast<QSize>(static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QAbstractItemView_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QAbstractItemView_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::setVisible(visible != 0);
}
void QAbstractItemView_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QAbstractItemView_SetWindowModifiedDefault(void* ptr, int 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));
}
int QAbstractItemView_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QAbstractItemView_HasHeightForWidth(void* ptr)
{
return static_cast<QAbstractItemView*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QAbstractItemView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QAbstractItemView*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QAbstractItemView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QAbstractItemView_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QAbstractItemView_SetHiddenDefault(void* ptr, int 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));
}
int QAbstractItemView_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QAbstractItemView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQAbstractScrollArea_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQAbstractScrollArea_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQAbstractScrollArea_DropEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQAbstractScrollArea_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void resizeEvent(QResizeEvent * event) { callbackQAbstractScrollArea_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
bool viewportEvent(QEvent * event) { return callbackQAbstractScrollArea_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
void contextMenuEvent(QContextMenuEvent * e) { callbackQAbstractScrollArea_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
void keyPressEvent(QKeyEvent * e) { callbackQAbstractScrollArea_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_MinimumSizeHint(const_cast<MyQAbstractScrollArea*>(this), this->objectName().toUtf8().data())); };
void mouseDoubleClickEvent(QMouseEvent * e) { callbackQAbstractScrollArea_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), e); };
void mouseMoveEvent(QMouseEvent * e) { callbackQAbstractScrollArea_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQAbstractScrollArea_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQAbstractScrollArea_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void scrollContentsBy(int dx, int dy) { callbackQAbstractScrollArea_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void setupViewport(QWidget * viewport) { callbackQAbstractScrollArea_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_SizeHint(const_cast<MyQAbstractScrollArea*>(this), this->objectName().toUtf8().data())); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQAbstractScrollArea_ViewportSizeHint(const_cast<MyQAbstractScrollArea*>(this), this->objectName().toUtf8().data())); };
void wheelEvent(QWheelEvent * e) { callbackQAbstractScrollArea_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void changeEvent(QEvent * ev) { callbackQAbstractScrollArea_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQAbstractScrollArea_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQAbstractScrollArea_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQAbstractScrollArea_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQAbstractScrollArea_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQAbstractScrollArea_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQAbstractScrollArea_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQAbstractScrollArea_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQAbstractScrollArea_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQAbstractScrollArea_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQAbstractScrollArea_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQAbstractScrollArea_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQAbstractScrollArea_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQAbstractScrollArea_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQAbstractScrollArea_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQAbstractScrollArea_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQAbstractScrollArea_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQAbstractScrollArea_HasHeightForWidth(const_cast<MyQAbstractScrollArea*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQAbstractScrollArea_HeightForWidth(const_cast<MyQAbstractScrollArea*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQAbstractScrollArea_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQAbstractScrollArea_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQAbstractScrollArea_InputMethodQuery(const_cast<MyQAbstractScrollArea*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQAbstractScrollArea_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQAbstractScrollArea_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQAbstractScrollArea_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQAbstractScrollArea_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQAbstractScrollArea_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQAbstractScrollArea_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQAbstractScrollArea_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQAbstractScrollArea_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQAbstractScrollArea_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQAbstractScrollArea_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQAbstractScrollArea_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQAbstractScrollArea_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQAbstractScrollArea_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQAbstractScrollArea_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQAbstractScrollArea_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQAbstractScrollArea_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQAbstractScrollArea_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQAbstractScrollArea_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQAbstractScrollArea_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQAbstractScrollArea_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQAbstractScrollArea_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractScrollArea_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractScrollArea_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractScrollArea_MetaObject(const_cast<MyQAbstractScrollArea*>(this), this->objectName().toUtf8().data())); };
};
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));
}
int QAbstractScrollArea_Event(void* ptr, void* event)
{
return static_cast<QAbstractScrollArea*>(ptr)->event(static_cast<QEvent*>(event));
}
int 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, int vqt)
{
static_cast<QAbstractScrollArea*>(ptr)->setHorizontalScrollBarPolicy(static_cast<Qt::ScrollBarPolicy>(vqt));
}
void QAbstractScrollArea_SetSizeAdjustPolicy(void* ptr, int policy)
{
static_cast<QAbstractScrollArea*>(ptr)->setSizeAdjustPolicy(static_cast<QAbstractScrollArea::SizeAdjustPolicy>(policy));
}
void QAbstractScrollArea_SetVerticalScrollBarPolicy(void* ptr, int vqt)
{
static_cast<QAbstractScrollArea*>(ptr)->setVerticalScrollBarPolicy(static_cast<Qt::ScrollBarPolicy>(vqt));
}
int QAbstractScrollArea_SizeAdjustPolicy(void* ptr)
{
return static_cast<QAbstractScrollArea*>(ptr)->sizeAdjustPolicy();
}
int QAbstractScrollArea_VerticalScrollBarPolicy(void* ptr)
{
return static_cast<QAbstractScrollArea*>(ptr)->verticalScrollBarPolicy();
}
int QAbstractScrollArea_ViewportEvent(void* ptr, void* event)
{
return static_cast<QAbstractScrollArea*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int 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, int 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 new QSize(static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->maximumViewportSize()).width(), static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->maximumViewportSize()).height());
}
void* QAbstractScrollArea_MinimumSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->minimumSizeHint()).height());
}
void* QAbstractScrollArea_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->sizeHint()).height());
}
void* QAbstractScrollArea_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::sizeHint()).width(), static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::sizeHint()).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 new QMargins(static_cast<QMargins>(static_cast<QAbstractScrollArea*>(ptr)->viewportMargins()).left(), static_cast<QMargins>(static_cast<QAbstractScrollArea*>(ptr)->viewportMargins()).top(), static_cast<QMargins>(static_cast<QAbstractScrollArea*>(ptr)->viewportMargins()).right(), static_cast<QMargins>(static_cast<QAbstractScrollArea*>(ptr)->viewportMargins()).bottom());
}
void* QAbstractScrollArea_ViewportSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->viewportSizeHint()).height());
}
void* QAbstractScrollArea_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::viewportSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QAbstractScrollArea_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QAbstractScrollArea_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::setVisible(visible != 0);
}
void QAbstractScrollArea_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QAbstractScrollArea_SetWindowModifiedDefault(void* ptr, int 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));
}
int QAbstractScrollArea_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QAbstractScrollArea_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QAbstractScrollArea*>(ptr)->focusNextPrevChild(next != 0);
}
int QAbstractScrollArea_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::focusNextPrevChild(next != 0);
}
int QAbstractScrollArea_HasHeightForWidth(void* ptr)
{
return static_cast<QAbstractScrollArea*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QAbstractScrollArea*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QAbstractScrollArea_InputMethodQueryDefault(void* ptr, int 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();
}
int QAbstractScrollArea_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QAbstractScrollArea*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QAbstractScrollArea_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QAbstractScrollArea*>(ptr)->QAbstractScrollArea::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QAbstractScrollArea_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QAbstractScrollArea*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QAbstractScrollArea_SetHiddenDefault(void* ptr, int 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));
}
int QAbstractScrollArea_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QAbstractScrollArea*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), vqt); };
void setValue(int vin) { callbackQAbstractSlider_SetValue(this, this->objectName().toUtf8().data(), vin); };
void Signal_ActionTriggered(int action) { callbackQAbstractSlider_ActionTriggered(this, this->objectName().toUtf8().data(), action); };
void changeEvent(QEvent * ev) { callbackQAbstractSlider_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void keyPressEvent(QKeyEvent * ev) { callbackQAbstractSlider_KeyPressEvent(this, this->objectName().toUtf8().data(), ev); };
void Signal_RangeChanged(int min, int max) { callbackQAbstractSlider_RangeChanged(this, this->objectName().toUtf8().data(), min, max); };
void setRange(int min, int max) { callbackQAbstractSlider_SetRange(this, this->objectName().toUtf8().data(), min, max); };
void sliderChange(QAbstractSlider::SliderChange change) { callbackQAbstractSlider_SliderChange(this, this->objectName().toUtf8().data(), change); };
void Signal_SliderMoved(int value) { callbackQAbstractSlider_SliderMoved(this, this->objectName().toUtf8().data(), value); };
void Signal_SliderPressed() { callbackQAbstractSlider_SliderPressed(this, this->objectName().toUtf8().data()); };
void Signal_SliderReleased() { callbackQAbstractSlider_SliderReleased(this, this->objectName().toUtf8().data()); };
void Signal_ValueChanged(int value) { callbackQAbstractSlider_ValueChanged(this, this->objectName().toUtf8().data(), value); };
void wheelEvent(QWheelEvent * e) { callbackQAbstractSlider_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void actionEvent(QActionEvent * event) { callbackQAbstractSlider_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQAbstractSlider_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQAbstractSlider_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQAbstractSlider_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQAbstractSlider_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQAbstractSlider_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQAbstractSlider_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQAbstractSlider_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQAbstractSlider_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQAbstractSlider_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQAbstractSlider_MinimumSizeHint(const_cast<MyQAbstractSlider*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQAbstractSlider_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQAbstractSlider_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQAbstractSlider_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQAbstractSlider_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQAbstractSlider_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQAbstractSlider_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQAbstractSlider_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQAbstractSlider_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQAbstractSlider_SizeHint(const_cast<MyQAbstractSlider*>(this), this->objectName().toUtf8().data())); };
bool close() { return callbackQAbstractSlider_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQAbstractSlider_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQAbstractSlider_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQAbstractSlider_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQAbstractSlider_HasHeightForWidth(const_cast<MyQAbstractSlider*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQAbstractSlider_HeightForWidth(const_cast<MyQAbstractSlider*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQAbstractSlider_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQAbstractSlider_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQAbstractSlider_InputMethodQuery(const_cast<MyQAbstractSlider*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQAbstractSlider_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQAbstractSlider_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQAbstractSlider_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQAbstractSlider_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQAbstractSlider_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQAbstractSlider_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQAbstractSlider_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQAbstractSlider_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQAbstractSlider_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQAbstractSlider_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQAbstractSlider_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQAbstractSlider_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQAbstractSlider_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQAbstractSlider_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQAbstractSlider_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQAbstractSlider_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQAbstractSlider_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQAbstractSlider_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQAbstractSlider_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQAbstractSlider_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQAbstractSlider_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQAbstractSlider_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQAbstractSlider_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQAbstractSlider_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQAbstractSlider_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractSlider_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractSlider_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractSlider_MetaObject(const_cast<MyQAbstractSlider*>(this), this->objectName().toUtf8().data())); };
};
int QAbstractSlider_HasTracking(void* ptr)
{
return static_cast<QAbstractSlider*>(ptr)->hasTracking();
}
int QAbstractSlider_InvertedAppearance(void* ptr)
{
return static_cast<QAbstractSlider*>(ptr)->invertedAppearance();
}
int QAbstractSlider_InvertedControls(void* ptr)
{
return static_cast<QAbstractSlider*>(ptr)->invertedControls();
}
int 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();
}
int 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, int vbo)
{
static_cast<QAbstractSlider*>(ptr)->setInvertedAppearance(vbo != 0);
}
void QAbstractSlider_SetInvertedControls(void* ptr, int 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, int 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, int 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, int 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));
}
int 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);
}
int 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, int action, int thresholdTime, int repeatTime)
{
static_cast<QAbstractSlider*>(ptr)->setRepeatAction(static_cast<QAbstractSlider::SliderAction>(action), thresholdTime, repeatTime);
}
void QAbstractSlider_SliderChange(void* ptr, int change)
{
static_cast<QAbstractSlider*>(ptr)->sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
}
void QAbstractSlider_SliderChangeDefault(void* ptr, int 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, int 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 new QSize(static_cast<QSize>(static_cast<QAbstractSlider*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractSlider*>(ptr)->minimumSizeHint()).height());
}
void* QAbstractSlider_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QAbstractSlider_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QAbstractSlider_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::setVisible(visible != 0);
}
void QAbstractSlider_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QAbstractSlider_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QAbstractSlider*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QAbstractSlider*>(ptr)->sizeHint()).height());
}
void* QAbstractSlider_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::sizeHint()).width(), static_cast<QSize>(static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::sizeHint()).height());
}
int QAbstractSlider_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QAbstractSlider_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QAbstractSlider*>(ptr)->focusNextPrevChild(next != 0);
}
int QAbstractSlider_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::focusNextPrevChild(next != 0);
}
int QAbstractSlider_HasHeightForWidth(void* ptr)
{
return static_cast<QAbstractSlider*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QAbstractSlider*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QAbstractSlider_InputMethodQueryDefault(void* ptr, int 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));
}
int QAbstractSlider_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QAbstractSlider*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QAbstractSlider_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QAbstractSlider*>(ptr)->QAbstractSlider::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QAbstractSlider_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QAbstractSlider*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QAbstractSlider_SetHiddenDefault(void* ptr, int 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));
}
int QAbstractSlider_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QAbstractSlider*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), event); };
void clear() { callbackQAbstractSpinBox_Clear(this, this->objectName().toUtf8().data()); };
void closeEvent(QCloseEvent * event) { callbackQAbstractSpinBox_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQAbstractSpinBox_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_EditingFinished() { callbackQAbstractSpinBox_EditingFinished(this, this->objectName().toUtf8().data()); };
void fixup(QString & input) const { callbackQAbstractSpinBox_Fixup(const_cast<MyQAbstractSpinBox*>(this), this->objectName().toUtf8().data(), input.toUtf8().data()); };
void focusInEvent(QFocusEvent * event) { callbackQAbstractSpinBox_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQAbstractSpinBox_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQAbstractSpinBox_HideEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQAbstractSpinBox_InputMethodQuery(const_cast<MyQAbstractSpinBox*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQAbstractSpinBox_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQAbstractSpinBox_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQAbstractSpinBox_MinimumSizeHint(const_cast<MyQAbstractSpinBox*>(this), this->objectName().toUtf8().data())); };
void mouseMoveEvent(QMouseEvent * event) { callbackQAbstractSpinBox_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQAbstractSpinBox_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQAbstractSpinBox_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQAbstractSpinBox_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void resizeEvent(QResizeEvent * event) { callbackQAbstractSpinBox_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void selectAll() { callbackQAbstractSpinBox_SelectAll(this, this->objectName().toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQAbstractSpinBox_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQAbstractSpinBox_SizeHint(const_cast<MyQAbstractSpinBox*>(this), this->objectName().toUtf8().data())); };
void stepBy(int steps) { callbackQAbstractSpinBox_StepBy(this, this->objectName().toUtf8().data(), steps); };
void stepDown() { callbackQAbstractSpinBox_StepDown(this, this->objectName().toUtf8().data()); };
StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQAbstractSpinBox_StepEnabled(const_cast<MyQAbstractSpinBox*>(this), this->objectName().toUtf8().data())); };
void stepUp() { callbackQAbstractSpinBox_StepUp(this, this->objectName().toUtf8().data()); };
QValidator::State validate(QString & input, int & pos) const { return static_cast<QValidator::State>(callbackQAbstractSpinBox_Validate(const_cast<MyQAbstractSpinBox*>(this), this->objectName().toUtf8().data(), input.toUtf8().data(), pos)); };
void wheelEvent(QWheelEvent * event) { callbackQAbstractSpinBox_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void actionEvent(QActionEvent * event) { callbackQAbstractSpinBox_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQAbstractSpinBox_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQAbstractSpinBox_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQAbstractSpinBox_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQAbstractSpinBox_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQAbstractSpinBox_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQAbstractSpinBox_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQAbstractSpinBox_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQAbstractSpinBox_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQAbstractSpinBox_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQAbstractSpinBox_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQAbstractSpinBox_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQAbstractSpinBox_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQAbstractSpinBox_Close(this, this->objectName().toUtf8().data()) != 0; };
bool focusNextPrevChild(bool next) { return callbackQAbstractSpinBox_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQAbstractSpinBox_HasHeightForWidth(const_cast<MyQAbstractSpinBox*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQAbstractSpinBox_HeightForWidth(const_cast<MyQAbstractSpinBox*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQAbstractSpinBox_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQAbstractSpinBox_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQAbstractSpinBox_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQAbstractSpinBox_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQAbstractSpinBox_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQAbstractSpinBox_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQAbstractSpinBox_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQAbstractSpinBox_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQAbstractSpinBox_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQAbstractSpinBox_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQAbstractSpinBox_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQAbstractSpinBox_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQAbstractSpinBox_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQAbstractSpinBox_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQAbstractSpinBox_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQAbstractSpinBox_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQAbstractSpinBox_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQAbstractSpinBox_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQAbstractSpinBox_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQAbstractSpinBox_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQAbstractSpinBox_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQAbstractSpinBox_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractSpinBox_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractSpinBox_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractSpinBox_MetaObject(const_cast<MyQAbstractSpinBox*>(this), this->objectName().toUtf8().data())); };
};
int QAbstractSpinBox_Alignment(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->alignment();
}
int QAbstractSpinBox_ButtonSymbols(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->buttonSymbols();
}
int QAbstractSpinBox_CorrectionMode(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->correctionMode();
}
int QAbstractSpinBox_HasAcceptableInput(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->hasAcceptableInput();
}
int QAbstractSpinBox_HasFrame(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->hasFrame();
}
int QAbstractSpinBox_IsAccelerated(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->isAccelerated();
}
int QAbstractSpinBox_IsGroupSeparatorShown(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->isGroupSeparatorShown();
}
int QAbstractSpinBox_IsReadOnly(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->isReadOnly();
}
int QAbstractSpinBox_KeyboardTracking(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->keyboardTracking();
}
void QAbstractSpinBox_SetAccelerated(void* ptr, int on)
{
static_cast<QAbstractSpinBox*>(ptr)->setAccelerated(on != 0);
}
void QAbstractSpinBox_SetAlignment(void* ptr, int flag)
{
static_cast<QAbstractSpinBox*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(flag));
}
void QAbstractSpinBox_SetButtonSymbols(void* ptr, int bs)
{
static_cast<QAbstractSpinBox*>(ptr)->setButtonSymbols(static_cast<QAbstractSpinBox::ButtonSymbols>(bs));
}
void QAbstractSpinBox_SetCorrectionMode(void* ptr, int cm)
{
static_cast<QAbstractSpinBox*>(ptr)->setCorrectionMode(static_cast<QAbstractSpinBox::CorrectionMode>(cm));
}
void QAbstractSpinBox_SetFrame(void* ptr, int vbo)
{
static_cast<QAbstractSpinBox*>(ptr)->setFrame(vbo != 0);
}
void QAbstractSpinBox_SetGroupSeparatorShown(void* ptr, int shown)
{
static_cast<QAbstractSpinBox*>(ptr)->setGroupSeparatorShown(shown != 0);
}
void QAbstractSpinBox_SetKeyboardTracking(void* ptr, int 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, int 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, int w)
{
static_cast<QAbstractSpinBox*>(ptr)->setWrapping(w != 0);
}
char* QAbstractSpinBox_SpecialValueText(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->specialValueText().toUtf8().data();
}
char* QAbstractSpinBox_Text(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->text().toUtf8().data();
}
int 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();
}
int QAbstractSpinBox_Event(void* ptr, void* event)
{
return static_cast<QAbstractSpinBox*>(ptr)->event(static_cast<QEvent*>(event));
}
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, int query)
{
return new QVariant(static_cast<QAbstractSpinBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QAbstractSpinBox_InputMethodQueryDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QAbstractSpinBox*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractSpinBox*>(ptr)->minimumSizeHint()).height());
}
void* QAbstractSpinBox_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QAbstractSpinBox*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QAbstractSpinBox*>(ptr)->sizeHint()).height());
}
void* QAbstractSpinBox_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::sizeHint()).width(), static_cast<QSize>(static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::sizeHint()).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");
}
int QAbstractSpinBox_StepEnabled(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->stepEnabled();
}
int 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));
}
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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QAbstractSpinBox_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QAbstractSpinBox_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::setVisible(visible != 0);
}
void QAbstractSpinBox_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QAbstractSpinBox_SetWindowModifiedDefault(void* ptr, int 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));
}
int QAbstractSpinBox_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QAbstractSpinBox_CloseDefault(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::close();
}
int QAbstractSpinBox_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QAbstractSpinBox*>(ptr)->focusNextPrevChild(next != 0);
}
int QAbstractSpinBox_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::focusNextPrevChild(next != 0);
}
int QAbstractSpinBox_HasHeightForWidth(void* ptr)
{
return static_cast<QAbstractSpinBox*>(ptr)->hasHeightForWidth();
}
int 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));
}
int QAbstractSpinBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QAbstractSpinBox*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QAbstractSpinBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QAbstractSpinBox*>(ptr)->QAbstractSpinBox::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QAbstractSpinBox_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QAbstractSpinBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QAbstractSpinBox_SetHiddenDefault(void* ptr, int 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));
}
int QAbstractSpinBox_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QAbstractSpinBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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 static_cast<QAccessibleWidget*>(ptr)->actionNames().join("|").toUtf8().data();
}
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, int t)
{
return static_cast<QAccessibleWidget*>(ptr)->interface_cast(static_cast<QAccessible::InterfaceType>(t));
}
int QAccessibleWidget_IsValid(void* ptr)
{
return static_cast<QAccessibleWidget*>(ptr)->isValid();
}
char* QAccessibleWidget_KeyBindingsForAction(void* ptr, char* actionName)
{
return static_cast<QAccessibleWidget*>(ptr)->keyBindingsForAction(QString(actionName)).join("|").toUtf8().data();
}
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 new QRect(static_cast<QRect>(static_cast<QAccessibleWidget*>(ptr)->rect()).x(), static_cast<QRect>(static_cast<QAccessibleWidget*>(ptr)->rect()).y(), static_cast<QRect>(static_cast<QAccessibleWidget*>(ptr)->rect()).width(), static_cast<QRect>(static_cast<QAccessibleWidget*>(ptr)->rect()).height());
}
int QAccessibleWidget_Role(void* ptr)
{
return static_cast<QAccessibleWidget*>(ptr)->role();
}
char* QAccessibleWidget_Text(void* ptr, int t)
{
return static_cast<QAccessibleWidget*>(ptr)->text(static_cast<QAccessible::Text>(t)).toUtf8().data();
}
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, int t, char* text)
{
static_cast<QAccessibleWidget*>(ptr)->setText(static_cast<QAccessible::Text>(t), QString(text));
}
void QAccessibleWidget_SetTextDefault(void* ptr, int t, char* text)
{
static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::setText(static_cast<QAccessible::Text>(t), QString(text));
}
char* QAccessibleWidget_LocalizedActionDescription(void* ptr, char* actionName)
{
return static_cast<QAccessibleWidget*>(ptr)->localizedActionDescription(QString(actionName)).toUtf8().data();
}
char* QAccessibleWidget_LocalizedActionDescriptionDefault(void* ptr, char* actionName)
{
return static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::localizedActionDescription(QString(actionName)).toUtf8().data();
}
char* QAccessibleWidget_LocalizedActionName(void* ptr, char* actionName)
{
return static_cast<QAccessibleWidget*>(ptr)->localizedActionName(QString(actionName)).toUtf8().data();
}
char* QAccessibleWidget_LocalizedActionNameDefault(void* ptr, char* actionName)
{
return static_cast<QAccessibleWidget*>(ptr)->QAccessibleWidget::localizedActionName(QString(actionName)).toUtf8().data();
}
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, this->objectName().toUtf8().data(), vbo); };
void setEnabled(bool vbo) { callbackQAction_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setVisible(bool vbo) { callbackQAction_SetVisible(this, this->objectName().toUtf8().data(), vbo); };
void toggle() { callbackQAction_Toggle(this, this->objectName().toUtf8().data()); };
void Signal_Changed() { callbackQAction_Changed(this, this->objectName().toUtf8().data()); };
void hover() { callbackQAction_Hover(this, this->objectName().toUtf8().data()); };
void Signal_Hovered() { callbackQAction_Hovered(this, this->objectName().toUtf8().data()); };
void setDisabled(bool b) { callbackQAction_SetDisabled(this, this->objectName().toUtf8().data(), b); };
void Signal_Toggled(bool checked) { callbackQAction_Toggled(this, this->objectName().toUtf8().data(), checked); };
void trigger() { callbackQAction_Trigger(this, this->objectName().toUtf8().data()); };
void Signal_Triggered(bool checked) { callbackQAction_Triggered(this, this->objectName().toUtf8().data(), checked); };
void timerEvent(QTimerEvent * event) { callbackQAction_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQAction_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQAction_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQAction_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQAction_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQAction_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQAction_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAction_MetaObject(const_cast<MyQAction*>(this), this->objectName().toUtf8().data())); };
};
int 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 static_cast<QAction*>(ptr)->iconText().toUtf8().data();
}
int QAction_IsCheckable(void* ptr)
{
return static_cast<QAction*>(ptr)->isCheckable();
}
int QAction_IsChecked(void* ptr)
{
return static_cast<QAction*>(ptr)->isChecked();
}
int QAction_IsEnabled(void* ptr)
{
return static_cast<QAction*>(ptr)->isEnabled();
}
int QAction_IsIconVisibleInMenu(void* ptr)
{
return static_cast<QAction*>(ptr)->isIconVisibleInMenu();
}
int QAction_IsVisible(void* ptr)
{
return static_cast<QAction*>(ptr)->isVisible();
}
int QAction_MenuRole(void* ptr)
{
return static_cast<QAction*>(ptr)->menuRole();
}
int QAction_Priority(void* ptr)
{
return static_cast<QAction*>(ptr)->priority();
}
void QAction_SetAutoRepeat(void* ptr, int vbo)
{
static_cast<QAction*>(ptr)->setAutoRepeat(vbo != 0);
}
void QAction_SetCheckable(void* ptr, int vbo)
{
static_cast<QAction*>(ptr)->setCheckable(vbo != 0);
}
void QAction_SetChecked(void* ptr, int 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, int 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, int visible)
{
static_cast<QAction*>(ptr)->setIconVisibleInMenu(visible != 0);
}
void QAction_SetMenuRole(void* ptr, int menuRole)
{
static_cast<QAction*>(ptr)->setMenuRole(static_cast<QAction::MenuRole>(menuRole));
}
void QAction_SetPriority(void* ptr, int 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, int 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, int 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));
}
int QAction_ShortcutContext(void* ptr)
{
return static_cast<QAction*>(ptr)->shortcutContext();
}
char* QAction_StatusTip(void* ptr)
{
return static_cast<QAction*>(ptr)->statusTip().toUtf8().data();
}
char* QAction_Text(void* ptr)
{
return static_cast<QAction*>(ptr)->text().toUtf8().data();
}
void QAction_Toggle(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QAction*>(ptr), "toggle");
}
char* QAction_ToolTip(void* ptr)
{
return static_cast<QAction*>(ptr)->toolTip().toUtf8().data();
}
char* QAction_WhatsThis(void* ptr)
{
return static_cast<QAction*>(ptr)->whatsThis().toUtf8().data();
}
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, int 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());
}
int 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();
}
int 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, int 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, int b)
{
static_cast<QAction*>(ptr)->setSeparator(b != 0);
}
void QAction_SetShortcuts2(void* ptr, int key)
{
static_cast<QAction*>(ptr)->setShortcuts(static_cast<QKeySequence::StandardKey>(key));
}
void* QAction_Shortcut(void* ptr)
{
return new QKeySequence(static_cast<QAction*>(ptr)->shortcut());
}
int 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, int 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, int 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));
}
int QAction_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QAction*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), vbo); };
void setExclusive(bool vbo) { callbackQActionGroup_SetExclusive(this, this->objectName().toUtf8().data(), vbo); };
void setVisible(bool vbo) { callbackQActionGroup_SetVisible(this, this->objectName().toUtf8().data(), vbo); };
void Signal_Hovered(QAction * action) { callbackQActionGroup_Hovered(this, this->objectName().toUtf8().data(), action); };
void setDisabled(bool b) { callbackQActionGroup_SetDisabled(this, this->objectName().toUtf8().data(), b); };
void Signal_Triggered(QAction * action) { callbackQActionGroup_Triggered(this, this->objectName().toUtf8().data(), action); };
void timerEvent(QTimerEvent * event) { callbackQActionGroup_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQActionGroup_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQActionGroup_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQActionGroup_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQActionGroup_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQActionGroup_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQActionGroup_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQActionGroup_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQActionGroup_MetaObject(const_cast<MyQActionGroup*>(this), this->objectName().toUtf8().data())); };
};
void* QActionGroup_AddAction(void* ptr, void* action)
{
return static_cast<QActionGroup*>(ptr)->addAction(static_cast<QAction*>(action));
}
int QActionGroup_IsEnabled(void* ptr)
{
return static_cast<QActionGroup*>(ptr)->isEnabled();
}
int QActionGroup_IsExclusive(void* ptr)
{
return static_cast<QActionGroup*>(ptr)->isExclusive();
}
int QActionGroup_IsVisible(void* ptr)
{
return static_cast<QActionGroup*>(ptr)->isVisible();
}
void QActionGroup_SetEnabled(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QActionGroup*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QActionGroup_SetExclusive(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QActionGroup*>(ptr), "setExclusive", Q_ARG(bool, vbo != 0));
}
void QActionGroup_SetVisible(void* ptr, int 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, int 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));
}
int QActionGroup_Event(void* ptr, void* e)
{
return static_cast<QActionGroup*>(ptr)->event(static_cast<QEvent*>(e));
}
int QActionGroup_EventDefault(void* ptr, void* e)
{
return static_cast<QActionGroup*>(ptr)->QActionGroup::event(static_cast<QEvent*>(e));
}
int QActionGroup_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QActionGroup*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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), this->objectName().toUtf8().data()); };
bool autoSipEnabled() const { return callbackQApplication_AutoSipEnabled(const_cast<MyQApplication*>(this), this->objectName().toUtf8().data()) != 0; };
void setAutoMaximizeThreshold(const int threshold) { callbackQApplication_SetAutoMaximizeThreshold(this, this->objectName().toUtf8().data(), threshold); };
void setAutoSipEnabled(const bool enabled) { callbackQApplication_SetAutoSipEnabled(this, this->objectName().toUtf8().data(), enabled); };
void setStyleSheet(const QString & sheet) { callbackQApplication_SetStyleSheet(this, this->objectName().toUtf8().data(), sheet.toUtf8().data()); };
void aboutQt() { callbackQApplication_AboutQt(this, this->objectName().toUtf8().data()); };
void closeAllWindows() { callbackQApplication_CloseAllWindows(this, this->objectName().toUtf8().data()); };
void Signal_FocusChanged(QWidget * old, QWidget * now) { callbackQApplication_FocusChanged(this, this->objectName().toUtf8().data(), old, now); };
void quit() { callbackQApplication_Quit(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQApplication_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQApplication_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQApplication_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQApplication_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQApplication_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQApplication_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQApplication_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQApplication_MetaObject(const_cast<MyQApplication*>(this), this->objectName().toUtf8().data())); };
};
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;
}
int 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 new QSize(static_cast<QSize>(QApplication::globalStrut()).width(), static_cast<QSize>(QApplication::globalStrut()).height());
}
int QApplication_QApplication_IsEffectEnabled(int 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, int 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(int effect, int 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 static_cast<QApplication*>(ptr)->styleSheet().toUtf8().data();
}
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] = aList[i].data();
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();
}
int 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());
}
int 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(int 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_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));
}
int QApplication_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QApplication*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), item); };
int count() const { return callbackQBoxLayout_Count(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data()); };
Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQBoxLayout_ExpandingDirections(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data())); };
bool hasHeightForWidth() const { return callbackQBoxLayout_HasHeightForWidth(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQBoxLayout_HeightForWidth(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data(), w); };
void invalidate() { callbackQBoxLayout_Invalidate(this, this->objectName().toUtf8().data()); };
QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQBoxLayout_ItemAt(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data(), index)); };
QSize maximumSize() const { return *static_cast<QSize*>(callbackQBoxLayout_MaximumSize(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data())); };
int minimumHeightForWidth(int w) const { return callbackQBoxLayout_MinimumHeightForWidth(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data(), w); };
QSize minimumSize() const { return *static_cast<QSize*>(callbackQBoxLayout_MinimumSize(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data())); };
void setGeometry(const QRect & r) { callbackQBoxLayout_SetGeometry(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(r).x(), static_cast<QRect>(r).y(), static_cast<QRect>(r).width(), static_cast<QRect>(r).height())); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQBoxLayout_SizeHint(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data())); };
QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQBoxLayout_TakeAt(this, this->objectName().toUtf8().data(), index)); };
QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQBoxLayout_ControlTypes(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data())); };
QRect geometry() const { return *static_cast<QRect*>(callbackQBoxLayout_Geometry(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data())); };
int indexOf(QWidget * widget) const { return callbackQBoxLayout_IndexOf(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data(), widget); };
bool isEmpty() const { return callbackQBoxLayout_IsEmpty(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data()) != 0; };
QLayout * layout() { return static_cast<QLayout*>(callbackQBoxLayout_Layout(this, this->objectName().toUtf8().data())); };
void timerEvent(QTimerEvent * event) { callbackQBoxLayout_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQBoxLayout_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQBoxLayout_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQBoxLayout_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQBoxLayout_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQBoxLayout_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQBoxLayout_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQBoxLayout_MetaObject(const_cast<MyQBoxLayout*>(this), this->objectName().toUtf8().data())); };
QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQBoxLayout_SpacerItem(this, this->objectName().toUtf8().data())); };
QWidget * widget() { return static_cast<QWidget*>(callbackQBoxLayout_Widget(this, this->objectName().toUtf8().data())); };
};
int QBoxLayout_Direction(void* ptr)
{
return static_cast<QBoxLayout*>(ptr)->direction();
}
void* QBoxLayout_NewQBoxLayout(int 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, int 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();
}
int QBoxLayout_ExpandingDirections(void* ptr)
{
return static_cast<QBoxLayout*>(ptr)->expandingDirections();
}
int QBoxLayout_ExpandingDirectionsDefault(void* ptr)
{
return static_cast<QBoxLayout*>(ptr)->QBoxLayout::expandingDirections();
}
int QBoxLayout_HasHeightForWidth(void* ptr)
{
return static_cast<QBoxLayout*>(ptr)->hasHeightForWidth();
}
int 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, int 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 new QSize(static_cast<QSize>(static_cast<QBoxLayout*>(ptr)->maximumSize()).width(), static_cast<QSize>(static_cast<QBoxLayout*>(ptr)->maximumSize()).height());
}
void* QBoxLayout_MaximumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QBoxLayout*>(ptr)->QBoxLayout::maximumSize()).width(), static_cast<QSize>(static_cast<QBoxLayout*>(ptr)->QBoxLayout::maximumSize()).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 new QSize(static_cast<QSize>(static_cast<QBoxLayout*>(ptr)->minimumSize()).width(), static_cast<QSize>(static_cast<QBoxLayout*>(ptr)->minimumSize()).height());
}
void* QBoxLayout_MinimumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QBoxLayout*>(ptr)->QBoxLayout::minimumSize()).width(), static_cast<QSize>(static_cast<QBoxLayout*>(ptr)->QBoxLayout::minimumSize()).height());
}
void QBoxLayout_SetDirection(void* ptr, int 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);
}
int QBoxLayout_SetStretchFactor2(void* ptr, void* layout, int stretch)
{
return static_cast<QBoxLayout*>(ptr)->setStretchFactor(static_cast<QLayout*>(layout), stretch);
}
int 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 new QSize(static_cast<QSize>(static_cast<QBoxLayout*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QBoxLayout*>(ptr)->sizeHint()).height());
}
void* QBoxLayout_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QBoxLayout*>(ptr)->QBoxLayout::sizeHint()).width(), static_cast<QSize>(static_cast<QBoxLayout*>(ptr)->QBoxLayout::sizeHint()).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();
}
int QBoxLayout_ControlTypes(void* ptr)
{
return static_cast<QBoxLayout*>(ptr)->controlTypes();
}
int QBoxLayout_ControlTypesDefault(void* ptr)
{
return static_cast<QBoxLayout*>(ptr)->QBoxLayout::controlTypes();
}
void* QBoxLayout_Geometry(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QBoxLayout*>(ptr)->geometry()).x(), static_cast<QRect>(static_cast<QBoxLayout*>(ptr)->geometry()).y(), static_cast<QRect>(static_cast<QBoxLayout*>(ptr)->geometry()).width(), static_cast<QRect>(static_cast<QBoxLayout*>(ptr)->geometry()).height());
}
void* QBoxLayout_GeometryDefault(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QBoxLayout*>(ptr)->QBoxLayout::geometry()).x(), static_cast<QRect>(static_cast<QBoxLayout*>(ptr)->QBoxLayout::geometry()).y(), static_cast<QRect>(static_cast<QBoxLayout*>(ptr)->QBoxLayout::geometry()).width(), static_cast<QRect>(static_cast<QBoxLayout*>(ptr)->QBoxLayout::geometry()).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));
}
int QBoxLayout_IsEmpty(void* ptr)
{
return static_cast<QBoxLayout*>(ptr)->isEmpty();
}
int 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));
}
int QBoxLayout_Event(void* ptr, void* e)
{
return static_cast<QBoxLayout*>(ptr)->event(static_cast<QEvent*>(e));
}
int QBoxLayout_EventDefault(void* ptr, void* e)
{
return static_cast<QBoxLayout*>(ptr)->QBoxLayout::event(static_cast<QEvent*>(e));
}
int QBoxLayout_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QBoxLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), button); };
void Signal_ButtonClicked2(int id) { callbackQButtonGroup_ButtonClicked2(this, this->objectName().toUtf8().data(), id); };
void Signal_ButtonPressed(QAbstractButton * button) { callbackQButtonGroup_ButtonPressed(this, this->objectName().toUtf8().data(), button); };
void Signal_ButtonPressed2(int id) { callbackQButtonGroup_ButtonPressed2(this, this->objectName().toUtf8().data(), id); };
void Signal_ButtonReleased(QAbstractButton * button) { callbackQButtonGroup_ButtonReleased(this, this->objectName().toUtf8().data(), button); };
void Signal_ButtonReleased2(int id) { callbackQButtonGroup_ButtonReleased2(this, this->objectName().toUtf8().data(), id); };
void Signal_ButtonToggled(QAbstractButton * button, bool checked) { callbackQButtonGroup_ButtonToggled(this, this->objectName().toUtf8().data(), button, checked); };
void Signal_ButtonToggled2(int id, bool checked) { callbackQButtonGroup_ButtonToggled2(this, this->objectName().toUtf8().data(), id, checked); };
void timerEvent(QTimerEvent * event) { callbackQButtonGroup_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQButtonGroup_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQButtonGroup_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQButtonGroup_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQButtonGroup_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQButtonGroup_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQButtonGroup_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQButtonGroup_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQButtonGroup_MetaObject(const_cast<MyQButtonGroup*>(this), this->objectName().toUtf8().data())); };
};
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_CheckedButton(void* ptr)
{
return static_cast<QButtonGroup*>(ptr)->checkedButton();
}
int QButtonGroup_CheckedId(void* ptr)
{
return static_cast<QButtonGroup*>(ptr)->checkedId();
}
int QButtonGroup_Exclusive(void* ptr)
{
return static_cast<QButtonGroup*>(ptr)->exclusive();
}
int QButtonGroup_Id(void* ptr, void* button)
{
return static_cast<QButtonGroup*>(ptr)->id(static_cast<QAbstractButton*>(button));
}
void QButtonGroup_RemoveButton(void* ptr, void* button)
{
static_cast<QButtonGroup*>(ptr)->removeButton(static_cast<QAbstractButton*>(button));
}
void QButtonGroup_SetExclusive(void* ptr, int vbo)
{
static_cast<QButtonGroup*>(ptr)->setExclusive(vbo != 0);
}
void QButtonGroup_SetId(void* ptr, void* button, int id)
{
static_cast<QButtonGroup*>(ptr)->setId(static_cast<QAbstractButton*>(button), id);
}
void QButtonGroup_DestroyQButtonGroup(void* ptr)
{
static_cast<QButtonGroup*>(ptr)->~QButtonGroup();
}
void QButtonGroup_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, int 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, int checked)
{
static_cast<QButtonGroup*>(ptr)->buttonToggled(id, checked != 0);
}
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));
}
int QButtonGroup_Event(void* ptr, void* e)
{
return static_cast<QButtonGroup*>(ptr)->event(static_cast<QEvent*>(e));
}
int QButtonGroup_EventDefault(void* ptr, void* e)
{
return static_cast<QButtonGroup*>(ptr)->QButtonGroup::event(static_cast<QEvent*>(e));
}
int QButtonGroup_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QButtonGroup*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), show); };
void setNavigationBarVisible(bool visible) { callbackQCalendarWidget_SetNavigationBarVisible(this, this->objectName().toUtf8().data(), visible); };
void Signal_CurrentPageChanged(int year, int month) { callbackQCalendarWidget_CurrentPageChanged(this, this->objectName().toUtf8().data(), year, month); };
void keyPressEvent(QKeyEvent * event) { callbackQCalendarWidget_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQCalendarWidget_MinimumSizeHint(const_cast<MyQCalendarWidget*>(this), this->objectName().toUtf8().data())); };
void mousePressEvent(QMouseEvent * event) { callbackQCalendarWidget_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void resizeEvent(QResizeEvent * event) { callbackQCalendarWidget_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_SelectionChanged() { callbackQCalendarWidget_SelectionChanged(this, this->objectName().toUtf8().data()); };
void setCurrentPage(int year, int month) { callbackQCalendarWidget_SetCurrentPage(this, this->objectName().toUtf8().data(), year, month); };
void showNextMonth() { callbackQCalendarWidget_ShowNextMonth(this, this->objectName().toUtf8().data()); };
void showNextYear() { callbackQCalendarWidget_ShowNextYear(this, this->objectName().toUtf8().data()); };
void showPreviousMonth() { callbackQCalendarWidget_ShowPreviousMonth(this, this->objectName().toUtf8().data()); };
void showPreviousYear() { callbackQCalendarWidget_ShowPreviousYear(this, this->objectName().toUtf8().data()); };
void showSelectedDate() { callbackQCalendarWidget_ShowSelectedDate(this, this->objectName().toUtf8().data()); };
void showToday() { callbackQCalendarWidget_ShowToday(this, this->objectName().toUtf8().data()); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQCalendarWidget_SizeHint(const_cast<MyQCalendarWidget*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQCalendarWidget_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQCalendarWidget_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQCalendarWidget_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQCalendarWidget_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQCalendarWidget_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQCalendarWidget_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQCalendarWidget_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQCalendarWidget_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQCalendarWidget_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQCalendarWidget_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQCalendarWidget_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQCalendarWidget_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQCalendarWidget_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQCalendarWidget_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQCalendarWidget_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQCalendarWidget_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQCalendarWidget_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQCalendarWidget_ShowEvent(this, this->objectName().toUtf8().data(), event); };
void changeEvent(QEvent * event) { callbackQCalendarWidget_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQCalendarWidget_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQCalendarWidget_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQCalendarWidget_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQCalendarWidget_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQCalendarWidget_HasHeightForWidth(const_cast<MyQCalendarWidget*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQCalendarWidget_HeightForWidth(const_cast<MyQCalendarWidget*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQCalendarWidget_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQCalendarWidget_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQCalendarWidget_InputMethodQuery(const_cast<MyQCalendarWidget*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQCalendarWidget_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQCalendarWidget_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQCalendarWidget_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQCalendarWidget_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQCalendarWidget_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQCalendarWidget_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQCalendarWidget_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQCalendarWidget_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQCalendarWidget_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQCalendarWidget_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQCalendarWidget_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQCalendarWidget_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQCalendarWidget_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQCalendarWidget_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQCalendarWidget_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQCalendarWidget_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQCalendarWidget_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQCalendarWidget_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQCalendarWidget_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQCalendarWidget_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQCalendarWidget_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQCalendarWidget_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQCalendarWidget_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQCalendarWidget_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQCalendarWidget_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQCalendarWidget_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCalendarWidget_MetaObject(const_cast<MyQCalendarWidget*>(this), this->objectName().toUtf8().data())); };
};
int QCalendarWidget_DateEditAcceptDelay(void* ptr)
{
return static_cast<QCalendarWidget*>(ptr)->dateEditAcceptDelay();
}
int QCalendarWidget_FirstDayOfWeek(void* ptr)
{
return static_cast<QCalendarWidget*>(ptr)->firstDayOfWeek();
}
int QCalendarWidget_HorizontalHeaderFormat(void* ptr)
{
return static_cast<QCalendarWidget*>(ptr)->horizontalHeaderFormat();
}
int QCalendarWidget_IsDateEditEnabled(void* ptr)
{
return static_cast<QCalendarWidget*>(ptr)->isDateEditEnabled();
}
int QCalendarWidget_IsGridVisible(void* ptr)
{
return static_cast<QCalendarWidget*>(ptr)->isGridVisible();
}
int QCalendarWidget_IsNavigationBarVisible(void* ptr)
{
return static_cast<QCalendarWidget*>(ptr)->isNavigationBarVisible();
}
int 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, int enable)
{
static_cast<QCalendarWidget*>(ptr)->setDateEditEnabled(enable != 0);
}
void QCalendarWidget_SetFirstDayOfWeek(void* ptr, int dayOfWeek)
{
static_cast<QCalendarWidget*>(ptr)->setFirstDayOfWeek(static_cast<Qt::DayOfWeek>(dayOfWeek));
}
void QCalendarWidget_SetGridVisible(void* ptr, int show)
{
QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setGridVisible", Q_ARG(bool, show != 0));
}
void QCalendarWidget_SetHorizontalHeaderFormat(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setNavigationBarVisible", Q_ARG(bool, visible != 0));
}
void QCalendarWidget_SetSelectionMode(void* ptr, int mode)
{
static_cast<QCalendarWidget*>(ptr)->setSelectionMode(static_cast<QCalendarWidget::SelectionMode>(mode));
}
void QCalendarWidget_SetVerticalHeaderFormat(void* ptr, int format)
{
static_cast<QCalendarWidget*>(ptr)->setVerticalHeaderFormat(static_cast<QCalendarWidget::VerticalHeaderFormat>(format));
}
int QCalendarWidget_VerticalHeaderFormat(void* ptr)
{
return static_cast<QCalendarWidget*>(ptr)->verticalHeaderFormat();
}
void* QCalendarWidget_NewQCalendarWidget(void* parent)
{
return new MyQCalendarWidget(static_cast<QWidget*>(parent));
}
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);
}
int QCalendarWidget_Event(void* ptr, void* event)
{
return static_cast<QCalendarWidget*>(ptr)->event(static_cast<QEvent*>(event));
}
int 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 new QSize(static_cast<QSize>(static_cast<QCalendarWidget*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QCalendarWidget*>(ptr)->minimumSizeHint()).height());
}
void* QCalendarWidget_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::minimumSizeHint()).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_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_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, int 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 new QSize(static_cast<QSize>(static_cast<QCalendarWidget*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QCalendarWidget*>(ptr)->sizeHint()).height());
}
void* QCalendarWidget_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::sizeHint()).width(), static_cast<QSize>(static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QCalendarWidget_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QCalendarWidget_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::setVisible(visible != 0);
}
void QCalendarWidget_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QCalendarWidget_SetWindowModifiedDefault(void* ptr, int 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));
}
int QCalendarWidget_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QCalendarWidget_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QCalendarWidget*>(ptr)->focusNextPrevChild(next != 0);
}
int QCalendarWidget_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::focusNextPrevChild(next != 0);
}
int QCalendarWidget_HasHeightForWidth(void* ptr)
{
return static_cast<QCalendarWidget*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QCalendarWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QCalendarWidget_InputMethodQueryDefault(void* ptr, int 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));
}
int QCalendarWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QCalendarWidget*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QCalendarWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QCalendarWidget*>(ptr)->QCalendarWidget::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QCalendarWidget_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QCalendarWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QCalendarWidget_SetHiddenDefault(void* ptr, int 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, this->objectName().toUtf8().data()); };
bool hitButton(const QPoint & pos) const { return callbackQCheckBox_HitButton(const_cast<MyQCheckBox*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(pos).x(), static_cast<QPoint>(pos).y())) != 0; };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQCheckBox_MinimumSizeHint(const_cast<MyQCheckBox*>(this), this->objectName().toUtf8().data())); };
void mouseMoveEvent(QMouseEvent * e) { callbackQCheckBox_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void nextCheckState() { callbackQCheckBox_NextCheckState(this, this->objectName().toUtf8().data()); };
void paintEvent(QPaintEvent * vqp) { callbackQCheckBox_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQCheckBox_SizeHint(const_cast<MyQCheckBox*>(this), this->objectName().toUtf8().data())); };
void Signal_StateChanged(int state) { callbackQCheckBox_StateChanged(this, this->objectName().toUtf8().data(), state); };
void setChecked(bool vbo) { callbackQCheckBox_SetChecked(this, this->objectName().toUtf8().data(), vbo); };
void setIconSize(const QSize & size) { callbackQCheckBox_SetIconSize(this, this->objectName().toUtf8().data(), new QSize(static_cast<QSize>(size).width(), static_cast<QSize>(size).height())); };
void toggle() { callbackQCheckBox_Toggle(this, this->objectName().toUtf8().data()); };
void animateClick(int msec) { callbackQCheckBox_AnimateClick(this, this->objectName().toUtf8().data(), msec); };
void changeEvent(QEvent * e) { callbackQCheckBox_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void click() { callbackQCheckBox_Click(this, this->objectName().toUtf8().data()); };
void focusInEvent(QFocusEvent * e) { callbackQCheckBox_FocusInEvent(this, this->objectName().toUtf8().data(), e); };
void focusOutEvent(QFocusEvent * e) { callbackQCheckBox_FocusOutEvent(this, this->objectName().toUtf8().data(), e); };
void keyPressEvent(QKeyEvent * e) { callbackQCheckBox_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void keyReleaseEvent(QKeyEvent * e) { callbackQCheckBox_KeyReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQCheckBox_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQCheckBox_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void actionEvent(QActionEvent * event) { callbackQCheckBox_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQCheckBox_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQCheckBox_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQCheckBox_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQCheckBox_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQCheckBox_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQCheckBox_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQCheckBox_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQCheckBox_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQCheckBox_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQCheckBox_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQCheckBox_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQCheckBox_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQCheckBox_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQCheckBox_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQCheckBox_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQCheckBox_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQCheckBox_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQCheckBox_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQCheckBox_HasHeightForWidth(const_cast<MyQCheckBox*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQCheckBox_HeightForWidth(const_cast<MyQCheckBox*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQCheckBox_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQCheckBox_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQCheckBox_InputMethodQuery(const_cast<MyQCheckBox*>(this), this->objectName().toUtf8().data(), query)); };
void lower() { callbackQCheckBox_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQCheckBox_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQCheckBox_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQCheckBox_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQCheckBox_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQCheckBox_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQCheckBox_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQCheckBox_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQCheckBox_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQCheckBox_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQCheckBox_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQCheckBox_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQCheckBox_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQCheckBox_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQCheckBox_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQCheckBox_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQCheckBox_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQCheckBox_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQCheckBox_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQCheckBox_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQCheckBox_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQCheckBox_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQCheckBox_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQCheckBox_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCheckBox_MetaObject(const_cast<MyQCheckBox*>(this), this->objectName().toUtf8().data())); };
};
int QCheckBox_IsTristate(void* ptr)
{
return static_cast<QCheckBox*>(ptr)->isTristate();
}
void QCheckBox_SetTristate(void* ptr, int 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));
}
int 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();
}
int QCheckBox_Event(void* ptr, void* e)
{
return static_cast<QCheckBox*>(ptr)->event(static_cast<QEvent*>(e));
}
int QCheckBox_HitButton(void* ptr, void* pos)
{
return static_cast<QCheckBox*>(ptr)->hitButton(*static_cast<QPoint*>(pos));
}
int 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 new QSize(static_cast<QSize>(static_cast<QCheckBox*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QCheckBox*>(ptr)->minimumSizeHint()).height());
}
void* QCheckBox_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QCheckBox*>(ptr)->QCheckBox::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QCheckBox*>(ptr)->QCheckBox::minimumSizeHint()).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, int state)
{
static_cast<QCheckBox*>(ptr)->setCheckState(static_cast<Qt::CheckState>(state));
}
void* QCheckBox_SizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QCheckBox*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QCheckBox*>(ptr)->sizeHint()).height());
}
void* QCheckBox_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QCheckBox*>(ptr)->QCheckBox::sizeHint()).width(), static_cast<QSize>(static_cast<QCheckBox*>(ptr)->QCheckBox::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}
void QCheckBox_SetCheckedDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QCheckBox_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QCheckBox_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QCheckBox*>(ptr)->QCheckBox::setVisible(visible != 0);
}
void QCheckBox_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QCheckBox_SetWindowModifiedDefault(void* ptr, int 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));
}
int QCheckBox_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QCheckBox_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QCheckBox*>(ptr)->focusNextPrevChild(next != 0);
}
int QCheckBox_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QCheckBox*>(ptr)->QCheckBox::focusNextPrevChild(next != 0);
}
int QCheckBox_HasHeightForWidth(void* ptr)
{
return static_cast<QCheckBox*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QCheckBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QCheckBox_InputMethodQueryDefault(void* ptr, int 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));
}
int QCheckBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QCheckBox*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QCheckBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QCheckBox*>(ptr)->QCheckBox::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QCheckBox_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QCheckBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QCheckBox_SetHiddenDefault(void* ptr, int 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));
}
int QCheckBox_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QCheckBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), e); };
void Signal_ColorSelected(const QColor & color) { callbackQColorDialog_ColorSelected(this, this->objectName().toUtf8().data(), new QColor(color)); };
void Signal_CurrentColorChanged(const QColor & color) { callbackQColorDialog_CurrentColorChanged(this, this->objectName().toUtf8().data(), new QColor(color)); };
void done(int result) { callbackQColorDialog_Done(this, this->objectName().toUtf8().data(), result); };
void setVisible(bool visible) { callbackQColorDialog_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void accept() { callbackQColorDialog_Accept(this, this->objectName().toUtf8().data()); };
void closeEvent(QCloseEvent * e) { callbackQColorDialog_CloseEvent(this, this->objectName().toUtf8().data(), e); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQColorDialog_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
int exec() { return callbackQColorDialog_Exec(this, this->objectName().toUtf8().data()); };
void keyPressEvent(QKeyEvent * e) { callbackQColorDialog_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQColorDialog_MinimumSizeHint(const_cast<MyQColorDialog*>(this), this->objectName().toUtf8().data())); };
void reject() { callbackQColorDialog_Reject(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * vqr) { callbackQColorDialog_ResizeEvent(this, this->objectName().toUtf8().data(), vqr); };
void showEvent(QShowEvent * event) { callbackQColorDialog_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQColorDialog_SizeHint(const_cast<MyQColorDialog*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQColorDialog_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQColorDialog_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQColorDialog_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQColorDialog_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQColorDialog_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQColorDialog_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQColorDialog_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQColorDialog_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQColorDialog_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQColorDialog_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQColorDialog_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQColorDialog_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQColorDialog_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQColorDialog_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setWindowModified(bool vbo) { callbackQColorDialog_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQColorDialog_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQColorDialog_Close(this, this->objectName().toUtf8().data()) != 0; };
bool focusNextPrevChild(bool next) { return callbackQColorDialog_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQColorDialog_HasHeightForWidth(const_cast<MyQColorDialog*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQColorDialog_HeightForWidth(const_cast<MyQColorDialog*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQColorDialog_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQColorDialog_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQColorDialog_InputMethodQuery(const_cast<MyQColorDialog*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQColorDialog_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQColorDialog_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQColorDialog_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQColorDialog_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQColorDialog_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQColorDialog_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQColorDialog_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQColorDialog_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQColorDialog_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQColorDialog_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQColorDialog_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQColorDialog_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQColorDialog_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQColorDialog_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQColorDialog_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQColorDialog_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQColorDialog_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQColorDialog_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQColorDialog_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQColorDialog_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQColorDialog_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQColorDialog_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQColorDialog_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQColorDialog_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQColorDialog_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQColorDialog_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQColorDialog_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQColorDialog_MetaObject(const_cast<MyQColorDialog*>(this), this->objectName().toUtf8().data())); };
};
void* QColorDialog_CurrentColor(void* ptr)
{
return new QColor(static_cast<QColorDialog*>(ptr)->currentColor());
}
int 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, int 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, int 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, int option, int 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, int visible)
{
static_cast<QColorDialog*>(ptr)->setVisible(visible != 0);
}
void QColorDialog_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QColorDialog*>(ptr)->QColorDialog::setVisible(visible != 0);
}
void* QColorDialog_QColorDialog_StandardColor(int index)
{
return new QColor(QColorDialog::standardColor(index));
}
int QColorDialog_TestOption(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QColorDialog*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QColorDialog*>(ptr)->minimumSizeHint()).height());
}
void* QColorDialog_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QColorDialog*>(ptr)->QColorDialog::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QColorDialog*>(ptr)->QColorDialog::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QColorDialog*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QColorDialog*>(ptr)->sizeHint()).height());
}
void* QColorDialog_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QColorDialog*>(ptr)->QColorDialog::sizeHint()).width(), static_cast<QSize>(static_cast<QColorDialog*>(ptr)->QColorDialog::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QColorDialog_SetEnabledDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QColorDialog_SetWindowModifiedDefault(void* ptr, int 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));
}
int QColorDialog_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QColorDialog_CloseDefault(void* ptr)
{
return static_cast<QColorDialog*>(ptr)->QColorDialog::close();
}
int QColorDialog_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QColorDialog*>(ptr)->focusNextPrevChild(next != 0);
}
int QColorDialog_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QColorDialog*>(ptr)->QColorDialog::focusNextPrevChild(next != 0);
}
int QColorDialog_HasHeightForWidth(void* ptr)
{
return static_cast<QColorDialog*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QColorDialog*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QColorDialog_InputMethodQueryDefault(void* ptr, int 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));
}
int QColorDialog_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QColorDialog*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QColorDialog_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QColorDialog*>(ptr)->QColorDialog::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QColorDialog_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QColorDialog*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QColorDialog_SetHiddenDefault(void* ptr, int 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));
}
int QColormap_Depth(void* ptr)
{
return static_cast<QColormap*>(ptr)->depth();
}
void* QColormap_QColormap_Instance(int screen)
{
return new QColormap(QColormap::instance(screen));
}
int QColormap_Mode(void* ptr)
{
return static_cast<QColormap*>(ptr)->mode();
}
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, this->objectName().toUtf8().data(), new QModelIndex(index))); };
void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQColumnView_CurrentChanged(this, this->objectName().toUtf8().data(), new QModelIndex(current), new QModelIndex(previous)); };
int horizontalOffset() const { return callbackQColumnView_HorizontalOffset(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data()); };
QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQColumnView_IndexAt(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(point).x(), static_cast<QPoint>(point).y()))); };
bool isIndexHidden(const QModelIndex & index) const { return callbackQColumnView_IsIndexHidden(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index)) != 0; };
QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQColumnView_MoveCursor(this, this->objectName().toUtf8().data(), cursorAction, modifiers)); };
void resizeEvent(QResizeEvent * event) { callbackQColumnView_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQColumnView_RowsInserted(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void scrollContentsBy(int dx, int dy) { callbackQColumnView_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQColumnView_ScrollTo(this, this->objectName().toUtf8().data(), new QModelIndex(index), hint); };
void selectAll() { callbackQColumnView_SelectAll(this, this->objectName().toUtf8().data()); };
void setModel(QAbstractItemModel * model) { callbackQColumnView_SetModel(this, this->objectName().toUtf8().data(), model); };
void setRootIndex(const QModelIndex & index) { callbackQColumnView_SetRootIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQColumnView_SetSelection(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), command); };
void setSelectionModel(QItemSelectionModel * newSelectionModel) { callbackQColumnView_SetSelectionModel(this, this->objectName().toUtf8().data(), newSelectionModel); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQColumnView_SizeHint(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data())); };
void Signal_UpdatePreviewWidget(const QModelIndex & index) { callbackQColumnView_UpdatePreviewWidget(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
int verticalOffset() const { return callbackQColumnView_VerticalOffset(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data()); };
QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQColumnView_VisualRect(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index))); };
QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQColumnView_VisualRegionForSelection(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data(), new QItemSelection(selection))); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQColumnView_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
bool viewportEvent(QEvent * event) { return callbackQColumnView_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
void clearSelection() { callbackQColumnView_ClearSelection(this, this->objectName().toUtf8().data()); };
void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQColumnView_CloseEditor(this, this->objectName().toUtf8().data(), editor, hint); };
void commitData(QWidget * editor) { callbackQColumnView_CommitData(this, this->objectName().toUtf8().data(), editor); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQColumnView_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQColumnView_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQColumnView_DropEvent(this, this->objectName().toUtf8().data(), event); };
void edit(const QModelIndex & index) { callbackQColumnView_Edit(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQColumnView_Edit2(this, this->objectName().toUtf8().data(), new QModelIndex(index), trigger, event) != 0; };
void editorDestroyed(QObject * editor) { callbackQColumnView_EditorDestroyed(this, this->objectName().toUtf8().data(), editor); };
void focusInEvent(QFocusEvent * event) { callbackQColumnView_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQColumnView_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * event) { callbackQColumnView_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQColumnView_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQColumnView_InputMethodQuery(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQColumnView_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyboardSearch(const QString & search) { callbackQColumnView_KeyboardSearch(this, this->objectName().toUtf8().data(), search.toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQColumnView_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQColumnView_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQColumnView_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQColumnView_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void reset() { callbackQColumnView_Reset(this, this->objectName().toUtf8().data()); };
void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQColumnView_RowsAboutToBeRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void scrollToBottom() { callbackQColumnView_ScrollToBottom(this, this->objectName().toUtf8().data()); };
void scrollToTop() { callbackQColumnView_ScrollToTop(this, this->objectName().toUtf8().data()); };
void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQColumnView_SelectionChanged(this, this->objectName().toUtf8().data(), new QItemSelection(selected), new QItemSelection(deselected)); };
QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQColumnView_SelectionCommand(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index), const_cast<QEvent*>(event))); };
void setCurrentIndex(const QModelIndex & index) { callbackQColumnView_SetCurrentIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
int sizeHintForColumn(int column) const { return callbackQColumnView_SizeHintForColumn(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data(), column); };
int sizeHintForRow(int row) const { return callbackQColumnView_SizeHintForRow(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data(), row); };
void startDrag(Qt::DropActions supportedActions) { callbackQColumnView_StartDrag(this, this->objectName().toUtf8().data(), supportedActions); };
void update(const QModelIndex & index) { callbackQColumnView_Update(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void updateGeometries() { callbackQColumnView_UpdateGeometries(this, this->objectName().toUtf8().data()); };
QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQColumnView_ViewOptions(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data())); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQColumnView_ViewportSizeHint(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data())); };
void paintEvent(QPaintEvent * event) { callbackQColumnView_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQColumnView_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQColumnView_MinimumSizeHint(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data())); };
void setupViewport(QWidget * viewport) { callbackQColumnView_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
void wheelEvent(QWheelEvent * e) { callbackQColumnView_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void changeEvent(QEvent * ev) { callbackQColumnView_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQColumnView_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQColumnView_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQColumnView_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQColumnView_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQColumnView_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQColumnView_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQColumnView_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQColumnView_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQColumnView_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQColumnView_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQColumnView_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQColumnView_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQColumnView_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQColumnView_HasHeightForWidth(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQColumnView_HeightForWidth(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQColumnView_Hide(this, this->objectName().toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * event) { callbackQColumnView_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQColumnView_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQColumnView_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQColumnView_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQColumnView_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQColumnView_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQColumnView_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQColumnView_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQColumnView_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQColumnView_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQColumnView_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQColumnView_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQColumnView_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQColumnView_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void updateMicroFocus() { callbackQColumnView_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQColumnView_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQColumnView_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQColumnView_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQColumnView_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQColumnView_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQColumnView_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQColumnView_MetaObject(const_cast<MyQColumnView*>(this), this->objectName().toUtf8().data())); };
};
int QColumnView_ResizeGripsVisible(void* ptr)
{
return static_cast<QColumnView*>(ptr)->resizeGripsVisible();
}
void QColumnView_SetResizeGripsVisible(void* ptr, int 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));
}
int QColumnView_IsIndexHidden(void* ptr, void* index)
{
return static_cast<QColumnView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}
int QColumnView_IsIndexHiddenDefault(void* ptr, void* index)
{
return static_cast<QColumnView*>(ptr)->QColumnView::isIndexHidden(*static_cast<QModelIndex*>(index));
}
void* QColumnView_MoveCursor(void* ptr, int cursorAction, int modifiers)
{
return new QModelIndex(static_cast<QColumnView*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}
void* QColumnView_MoveCursorDefault(void* ptr, int cursorAction, int 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, int hint)
{
static_cast<QColumnView*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}
void QColumnView_ScrollToDefault(void* ptr, void* index, int 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, int command)
{
static_cast<QColumnView*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QColumnView_SetSelectionDefault(void* ptr, void* rect, int 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 new QSize(static_cast<QSize>(static_cast<QColumnView*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QColumnView*>(ptr)->sizeHint()).height());
}
void* QColumnView_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QColumnView*>(ptr)->QColumnView::sizeHint()).width(), static_cast<QSize>(static_cast<QColumnView*>(ptr)->QColumnView::sizeHint()).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 new QRect(static_cast<QRect>(static_cast<QColumnView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QColumnView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QColumnView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QColumnView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).height());
}
void* QColumnView_VisualRectDefault(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QColumnView*>(ptr)->QColumnView::visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QColumnView*>(ptr)->QColumnView::visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QColumnView*>(ptr)->QColumnView::visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QColumnView*>(ptr)->QColumnView::visualRect(*static_cast<QModelIndex*>(index))).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));
}
int QColumnView_ViewportEvent(void* ptr, void* event)
{
return static_cast<QColumnView*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int 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, int 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, int 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));
}
int QColumnView_Edit2(void* ptr, void* index, int trigger, void* event)
{
return static_cast<QColumnView*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}
int QColumnView_Edit2Default(void* ptr, void* index, int 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));
}
int QColumnView_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QColumnView*>(ptr)->focusNextPrevChild(next != 0);
}
int QColumnView_FocusNextPrevChildDefault(void* ptr, int 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, int query)
{
return new QVariant(static_cast<QColumnView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QColumnView_InputMethodQueryDefault(void* ptr, int 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));
}
int QColumnView_SelectionCommand(void* ptr, void* index, void* event)
{
return static_cast<QColumnView*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}
int 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, int supportedActions)
{
static_cast<QColumnView*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}
void QColumnView_StartDragDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QColumnView*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QColumnView*>(ptr)->viewportSizeHint()).height());
}
void* QColumnView_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QColumnView*>(ptr)->QColumnView::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QColumnView*>(ptr)->QColumnView::viewportSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QColumnView*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QColumnView*>(ptr)->minimumSizeHint()).height());
}
void* QColumnView_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QColumnView*>(ptr)->QColumnView::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QColumnView*>(ptr)->QColumnView::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QColumnView_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QColumnView_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QColumnView*>(ptr)->QColumnView::setVisible(visible != 0);
}
void QColumnView_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QColumnView_SetWindowModifiedDefault(void* ptr, int 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));
}
int QColumnView_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QColumnView_HasHeightForWidth(void* ptr)
{
return static_cast<QColumnView*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QColumnView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QColumnView*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QColumnView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QColumnView*>(ptr)->QColumnView::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QColumnView_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QColumnView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QColumnView_SetHiddenDefault(void* ptr, int 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));
}
int QColumnView_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QColumnView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), index); };
void setCurrentText(const QString & text) { callbackQComboBox_SetCurrentText(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void Signal_Activated2(const QString & text) { callbackQComboBox_Activated2(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void Signal_Activated(int index) { callbackQComboBox_Activated(this, this->objectName().toUtf8().data(), index); };
void changeEvent(QEvent * e) { callbackQComboBox_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void clear() { callbackQComboBox_Clear(this, this->objectName().toUtf8().data()); };
void clearEditText() { callbackQComboBox_ClearEditText(this, this->objectName().toUtf8().data()); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQComboBox_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
void Signal_CurrentIndexChanged2(const QString & text) { callbackQComboBox_CurrentIndexChanged2(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void Signal_CurrentIndexChanged(int index) { callbackQComboBox_CurrentIndexChanged(this, this->objectName().toUtf8().data(), index); };
void Signal_CurrentTextChanged(const QString & text) { callbackQComboBox_CurrentTextChanged(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void Signal_EditTextChanged(const QString & text) { callbackQComboBox_EditTextChanged(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void focusInEvent(QFocusEvent * e) { callbackQComboBox_FocusInEvent(this, this->objectName().toUtf8().data(), e); };
void focusOutEvent(QFocusEvent * e) { callbackQComboBox_FocusOutEvent(this, this->objectName().toUtf8().data(), e); };
void hideEvent(QHideEvent * e) { callbackQComboBox_HideEvent(this, this->objectName().toUtf8().data(), e); };
void hidePopup() { callbackQComboBox_HidePopup(this, this->objectName().toUtf8().data()); };
void Signal_Highlighted2(const QString & text) { callbackQComboBox_Highlighted2(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void Signal_Highlighted(int index) { callbackQComboBox_Highlighted(this, this->objectName().toUtf8().data(), index); };
void inputMethodEvent(QInputMethodEvent * e) { callbackQComboBox_InputMethodEvent(this, this->objectName().toUtf8().data(), e); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQComboBox_InputMethodQuery(const_cast<MyQComboBox*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * e) { callbackQComboBox_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void keyReleaseEvent(QKeyEvent * e) { callbackQComboBox_KeyReleaseEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQComboBox_MinimumSizeHint(const_cast<MyQComboBox*>(this), this->objectName().toUtf8().data())); };
void mousePressEvent(QMouseEvent * e) { callbackQComboBox_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQComboBox_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void paintEvent(QPaintEvent * e) { callbackQComboBox_PaintEvent(this, this->objectName().toUtf8().data(), e); };
void resizeEvent(QResizeEvent * e) { callbackQComboBox_ResizeEvent(this, this->objectName().toUtf8().data(), e); };
void setEditText(const QString & text) { callbackQComboBox_SetEditText(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void showEvent(QShowEvent * e) { callbackQComboBox_ShowEvent(this, this->objectName().toUtf8().data(), e); };
void showPopup() { callbackQComboBox_ShowPopup(this, this->objectName().toUtf8().data()); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQComboBox_SizeHint(const_cast<MyQComboBox*>(this), this->objectName().toUtf8().data())); };
void wheelEvent(QWheelEvent * e) { callbackQComboBox_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void actionEvent(QActionEvent * event) { callbackQComboBox_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQComboBox_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQComboBox_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQComboBox_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQComboBox_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQComboBox_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQComboBox_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQComboBox_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQComboBox_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQComboBox_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQComboBox_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQComboBox_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQComboBox_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQComboBox_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQComboBox_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQComboBox_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQComboBox_HasHeightForWidth(const_cast<MyQComboBox*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQComboBox_HeightForWidth(const_cast<MyQComboBox*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQComboBox_Hide(this, this->objectName().toUtf8().data()); };
void lower() { callbackQComboBox_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQComboBox_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQComboBox_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQComboBox_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQComboBox_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQComboBox_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQComboBox_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQComboBox_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQComboBox_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQComboBox_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQComboBox_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQComboBox_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQComboBox_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQComboBox_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQComboBox_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQComboBox_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQComboBox_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQComboBox_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQComboBox_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQComboBox_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQComboBox_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQComboBox_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQComboBox_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQComboBox_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQComboBox_MetaObject(const_cast<MyQComboBox*>(this), this->objectName().toUtf8().data())); };
};
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 static_cast<QComboBox*>(ptr)->currentText().toUtf8().data();
}
int QComboBox_DuplicatesEnabled(void* ptr)
{
return static_cast<QComboBox*>(ptr)->duplicatesEnabled();
}
int QComboBox_HasFrame(void* ptr)
{
return static_cast<QComboBox*>(ptr)->hasFrame();
}
void* QComboBox_IconSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QComboBox*>(ptr)->iconSize()).width(), static_cast<QSize>(static_cast<QComboBox*>(ptr)->iconSize()).height());
}
int QComboBox_InsertPolicy(void* ptr)
{
return static_cast<QComboBox*>(ptr)->insertPolicy();
}
int 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, int enable)
{
static_cast<QComboBox*>(ptr)->setDuplicatesEnabled(enable != 0);
}
void QComboBox_SetEditable(void* ptr, int editable)
{
static_cast<QComboBox*>(ptr)->setEditable(editable != 0);
}
void QComboBox_SetFrame(void* ptr, int 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, int 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, int 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));
}
int 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));
}
int 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, int flags)
{
return static_cast<QComboBox*>(ptr)->findData(*static_cast<QVariant*>(data), role, static_cast<Qt::MatchFlag>(flags));
}
int QComboBox_FindText(void* ptr, char* text, int 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, int query)
{
return new QVariant(static_cast<QComboBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QComboBox_InputMethodQueryDefault(void* ptr, int 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 static_cast<QComboBox*>(ptr)->itemText(index).toUtf8().data();
}
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 new QSize(static_cast<QSize>(static_cast<QComboBox*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QComboBox*>(ptr)->minimumSizeHint()).height());
}
void* QComboBox_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QComboBox*>(ptr)->QComboBox::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QComboBox*>(ptr)->QComboBox::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QComboBox*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QComboBox*>(ptr)->sizeHint()).height());
}
void* QComboBox_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QComboBox*>(ptr)->QComboBox::sizeHint()).width(), static_cast<QSize>(static_cast<QComboBox*>(ptr)->QComboBox::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QComboBox_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QComboBox_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QComboBox*>(ptr)->QComboBox::setVisible(visible != 0);
}
void QComboBox_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QComboBox_SetWindowModifiedDefault(void* ptr, int 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));
}
int QComboBox_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QComboBox_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QComboBox*>(ptr)->focusNextPrevChild(next != 0);
}
int QComboBox_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QComboBox*>(ptr)->QComboBox::focusNextPrevChild(next != 0);
}
int QComboBox_HasHeightForWidth(void* ptr)
{
return static_cast<QComboBox*>(ptr)->hasHeightForWidth();
}
int 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));
}
int QComboBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QComboBox*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QComboBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QComboBox*>(ptr)->QComboBox::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QComboBox_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QComboBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QComboBox_SetHiddenDefault(void* ptr, int 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));
}
int QComboBox_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QComboBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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), this->objectName().toUtf8().data(), width); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQCommandLinkButton_MinimumSizeHint(const_cast<MyQCommandLinkButton*>(this), this->objectName().toUtf8().data())); };
void paintEvent(QPaintEvent * vqp) { callbackQCommandLinkButton_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQCommandLinkButton_SizeHint(const_cast<MyQCommandLinkButton*>(this), this->objectName().toUtf8().data())); };
void focusInEvent(QFocusEvent * e) { callbackQCommandLinkButton_FocusInEvent(this, this->objectName().toUtf8().data(), e); };
void focusOutEvent(QFocusEvent * e) { callbackQCommandLinkButton_FocusOutEvent(this, this->objectName().toUtf8().data(), e); };
bool hitButton(const QPoint & pos) const { return callbackQCommandLinkButton_HitButton(const_cast<MyQCommandLinkButton*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(pos).x(), static_cast<QPoint>(pos).y())) != 0; };
void keyPressEvent(QKeyEvent * e) { callbackQCommandLinkButton_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void showMenu() { callbackQCommandLinkButton_ShowMenu(this, this->objectName().toUtf8().data()); };
void setChecked(bool vbo) { callbackQCommandLinkButton_SetChecked(this, this->objectName().toUtf8().data(), vbo); };
void setIconSize(const QSize & size) { callbackQCommandLinkButton_SetIconSize(this, this->objectName().toUtf8().data(), new QSize(static_cast<QSize>(size).width(), static_cast<QSize>(size).height())); };
void toggle() { callbackQCommandLinkButton_Toggle(this, this->objectName().toUtf8().data()); };
void animateClick(int msec) { callbackQCommandLinkButton_AnimateClick(this, this->objectName().toUtf8().data(), msec); };
void changeEvent(QEvent * e) { callbackQCommandLinkButton_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void checkStateSet() { callbackQCommandLinkButton_CheckStateSet(this, this->objectName().toUtf8().data()); };
void click() { callbackQCommandLinkButton_Click(this, this->objectName().toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * e) { callbackQCommandLinkButton_KeyReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void mouseMoveEvent(QMouseEvent * e) { callbackQCommandLinkButton_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQCommandLinkButton_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQCommandLinkButton_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void nextCheckState() { callbackQCommandLinkButton_NextCheckState(this, this->objectName().toUtf8().data()); };
void actionEvent(QActionEvent * event) { callbackQCommandLinkButton_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQCommandLinkButton_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQCommandLinkButton_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQCommandLinkButton_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQCommandLinkButton_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQCommandLinkButton_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQCommandLinkButton_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQCommandLinkButton_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQCommandLinkButton_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQCommandLinkButton_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQCommandLinkButton_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQCommandLinkButton_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQCommandLinkButton_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQCommandLinkButton_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQCommandLinkButton_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQCommandLinkButton_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQCommandLinkButton_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQCommandLinkButton_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQCommandLinkButton_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQCommandLinkButton_HasHeightForWidth(const_cast<MyQCommandLinkButton*>(this), this->objectName().toUtf8().data()) != 0; };
void hide() { callbackQCommandLinkButton_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQCommandLinkButton_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQCommandLinkButton_InputMethodQuery(const_cast<MyQCommandLinkButton*>(this), this->objectName().toUtf8().data(), query)); };
void lower() { callbackQCommandLinkButton_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQCommandLinkButton_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQCommandLinkButton_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQCommandLinkButton_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQCommandLinkButton_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQCommandLinkButton_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQCommandLinkButton_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQCommandLinkButton_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQCommandLinkButton_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQCommandLinkButton_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQCommandLinkButton_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQCommandLinkButton_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQCommandLinkButton_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQCommandLinkButton_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQCommandLinkButton_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQCommandLinkButton_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQCommandLinkButton_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQCommandLinkButton_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQCommandLinkButton_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQCommandLinkButton_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQCommandLinkButton_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQCommandLinkButton_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQCommandLinkButton_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQCommandLinkButton_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCommandLinkButton_MetaObject(const_cast<MyQCommandLinkButton*>(this), this->objectName().toUtf8().data())); };
};
char* QCommandLinkButton_Description(void* ptr)
{
return static_cast<QCommandLinkButton*>(ptr)->description().toUtf8().data();
}
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));
}
int 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 new QSize(static_cast<QSize>(static_cast<QCommandLinkButton*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QCommandLinkButton*>(ptr)->minimumSizeHint()).height());
}
void* QCommandLinkButton_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QCommandLinkButton*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QCommandLinkButton*>(ptr)->sizeHint()).height());
}
void* QCommandLinkButton_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::sizeHint()).width(), static_cast<QSize>(static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::sizeHint()).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));
}
int QCommandLinkButton_HitButton(void* ptr, void* pos)
{
return static_cast<QCommandLinkButton*>(ptr)->hitButton(*static_cast<QPoint*>(pos));
}
int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}
void QCommandLinkButton_SetCheckedDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QCommandLinkButton_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QCommandLinkButton_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::setVisible(visible != 0);
}
void QCommandLinkButton_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QCommandLinkButton_SetWindowModifiedDefault(void* ptr, int 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));
}
int QCommandLinkButton_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QCommandLinkButton_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QCommandLinkButton*>(ptr)->focusNextPrevChild(next != 0);
}
int QCommandLinkButton_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::focusNextPrevChild(next != 0);
}
int QCommandLinkButton_HasHeightForWidth(void* ptr)
{
return static_cast<QCommandLinkButton*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QCommandLinkButton*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QCommandLinkButton_InputMethodQueryDefault(void* ptr, int 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));
}
int QCommandLinkButton_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QCommandLinkButton*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QCommandLinkButton_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QCommandLinkButton*>(ptr)->QCommandLinkButton::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QCommandLinkButton_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QCommandLinkButton*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QCommandLinkButton_SetHiddenDefault(void* ptr, int 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));
}
int QCommandLinkButton_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QCommandLinkButton*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), iconMode, new 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), this->objectName().toUtf8().data(), cc, const_cast<QStyleOptionComplex*>(opt), new QPoint(static_cast<QPoint>(pt).x(), static_cast<QPoint>(pt).y()), 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), m, const_cast<QStyleOption*>(opt), const_cast<QWidget*>(widget)); };
void polish(QApplication * app) { callbackQCommonStyle_Polish2(this, this->objectName().toUtf8().data(), app); };
void polish(QPalette & pal) { callbackQCommonStyle_Polish(this, this->objectName().toUtf8().data(), new QPalette(pal)); };
void polish(QWidget * widget) { callbackQCommonStyle_Polish3(this, this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), ct, const_cast<QStyleOption*>(opt), new QSize(static_cast<QSize>(csz).width(), static_cast<QSize>(csz).height()), 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), sr, const_cast<QStyleOption*>(opt), const_cast<QWidget*>(widget))); };
void unpolish(QApplication * application) { callbackQCommonStyle_Unpolish2(this, this->objectName().toUtf8().data(), application); };
void unpolish(QWidget * widget) { callbackQCommonStyle_Unpolish(this, this->objectName().toUtf8().data(), widget); };
void drawItemPixmap(QPainter * painter, const QRect & rectangle, int alignment, const QPixmap & pixmap) const { callbackQCommonStyle_DrawItemPixmap(const_cast<MyQCommonStyle*>(this), this->objectName().toUtf8().data(), painter, new QRect(static_cast<QRect>(rectangle).x(), static_cast<QRect>(rectangle).y(), static_cast<QRect>(rectangle).width(), static_cast<QRect>(rectangle).height()), alignment, new 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), this->objectName().toUtf8().data(), painter, new QRect(static_cast<QRect>(rectangle).x(), static_cast<QRect>(rectangle).y(), static_cast<QRect>(rectangle).width(), static_cast<QRect>(rectangle).height()), alignment, new QPalette(palette), enabled, text.toUtf8().data(), textRole); };
QRect itemPixmapRect(const QRect & rectangle, int alignment, const QPixmap & pixmap) const { return *static_cast<QRect*>(callbackQCommonStyle_ItemPixmapRect(const_cast<MyQCommonStyle*>(this), this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rectangle).x(), static_cast<QRect>(rectangle).y(), static_cast<QRect>(rectangle).width(), static_cast<QRect>(rectangle).height()), alignment, new 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), this->objectName().toUtf8().data(), new QFontMetrics(metrics), new QRect(static_cast<QRect>(rectangle).x(), static_cast<QRect>(rectangle).y(), static_cast<QRect>(rectangle).width(), static_cast<QRect>(rectangle).height()), alignment, enabled, text.toUtf8().data())); };
QIcon standardIcon(QStyle::StandardPixmap standardIcon, const QStyleOption * option, const QWidget * widget) const { return *static_cast<QIcon*>(callbackQCommonStyle_StandardIcon(const_cast<MyQCommonStyle*>(this), this->objectName().toUtf8().data(), standardIcon, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
QPalette standardPalette() const { return *static_cast<QPalette*>(callbackQCommonStyle_StandardPalette(const_cast<MyQCommonStyle*>(this), this->objectName().toUtf8().data())); };
void timerEvent(QTimerEvent * event) { callbackQCommonStyle_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQCommonStyle_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQCommonStyle_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQCommonStyle_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQCommonStyle_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQCommonStyle_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQCommonStyle_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQCommonStyle_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCommonStyle_MetaObject(const_cast<MyQCommonStyle*>(this), this->objectName().toUtf8().data())); };
};
void* QCommonStyle_NewQCommonStyle()
{
return new MyQCommonStyle();
}
void QCommonStyle_DrawComplexControl(void* ptr, int 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, int 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, int 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, int 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, int 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, int 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, int 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, int 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)));
}
int QCommonStyle_HitTestComplexControl(void* ptr, int 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));
}
int QCommonStyle_HitTestComplexControlDefault(void* ptr, int 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, int control1, int control2, int 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, int control1, int control2, int 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, int 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, int 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, int ct, void* opt, void* csz, void* widget)
{
return new QSize(static_cast<QSize>(static_cast<QCommonStyle*>(ptr)->sizeFromContents(static_cast<QStyle::ContentsType>(ct), static_cast<QStyleOption*>(opt), *static_cast<QSize*>(csz), static_cast<QWidget*>(widget))).width(), static_cast<QSize>(static_cast<QCommonStyle*>(ptr)->sizeFromContents(static_cast<QStyle::ContentsType>(ct), static_cast<QStyleOption*>(opt), *static_cast<QSize*>(csz), static_cast<QWidget*>(widget))).height());
}
void* QCommonStyle_SizeFromContentsDefault(void* ptr, int ct, void* opt, void* csz, void* widget)
{
return new QSize(static_cast<QSize>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::sizeFromContents(static_cast<QStyle::ContentsType>(ct), static_cast<QStyleOption*>(opt), *static_cast<QSize*>(csz), static_cast<QWidget*>(widget))).width(), static_cast<QSize>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::sizeFromContents(static_cast<QStyle::ContentsType>(ct), static_cast<QStyleOption*>(opt), *static_cast<QSize*>(csz), static_cast<QWidget*>(widget))).height());
}
void* QCommonStyle_StandardPixmap(void* ptr, int 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, int 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, int 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, int 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, int cc, void* opt, int sc, void* widget)
{
return new QRect(static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).x(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).y(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).width(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).height());
}
void* QCommonStyle_SubControlRectDefault(void* ptr, int cc, void* opt, int sc, void* widget)
{
return new QRect(static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).x(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).y(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).width(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(opt), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).height());
}
void* QCommonStyle_SubElementRect(void* ptr, int sr, void* opt, void* widget)
{
return new QRect(static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(sr), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget))).x(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(sr), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget))).y(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(sr), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget))).width(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(sr), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget))).height());
}
void* QCommonStyle_SubElementRectDefault(void* ptr, int sr, void* opt, void* widget)
{
return new QRect(static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::subElementRect(static_cast<QStyle::SubElement>(sr), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget))).x(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::subElementRect(static_cast<QStyle::SubElement>(sr), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget))).y(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::subElementRect(static_cast<QStyle::SubElement>(sr), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget))).width(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::subElementRect(static_cast<QStyle::SubElement>(sr), static_cast<QStyleOption*>(opt), static_cast<QWidget*>(widget))).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, int enabled, char* text, int 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, int enabled, char* text, int 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 new QRect(static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).x(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).y(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).width(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).height());
}
void* QCommonStyle_ItemPixmapRectDefault(void* ptr, void* rectangle, int alignment, void* pixmap)
{
return new QRect(static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).x(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).y(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).width(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).height());
}
void* QCommonStyle_ItemTextRect(void* ptr, void* metrics, void* rectangle, int alignment, int enabled, char* text)
{
return new QRect(static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).x(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).y(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).width(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).height());
}
void* QCommonStyle_ItemTextRectDefault(void* ptr, void* metrics, void* rectangle, int alignment, int enabled, char* text)
{
return new QRect(static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).x(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).y(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).width(), static_cast<QRect>(static_cast<QCommonStyle*>(ptr)->QCommonStyle::itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).height());
}
void* QCommonStyle_StandardIcon(void* ptr, int 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, int 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));
}
int QCommonStyle_Event(void* ptr, void* e)
{
return static_cast<QCommonStyle*>(ptr)->event(static_cast<QEvent*>(e));
}
int QCommonStyle_EventDefault(void* ptr, void* e)
{
return static_cast<QCommonStyle*>(ptr)->QCommonStyle::event(static_cast<QEvent*>(e));
}
int QCommonStyle_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QCommonStyle*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), prefix.toUtf8().data()); };
void setWrapAround(bool wrap) { callbackQCompleter_SetWrapAround(this, this->objectName().toUtf8().data(), wrap); };
void Signal_Activated2(const QModelIndex & index) { callbackQCompleter_Activated2(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void Signal_Activated(const QString & text) { callbackQCompleter_Activated(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void complete(const QRect & rect) { callbackQCompleter_Complete(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height())); };
void Signal_Highlighted2(const QModelIndex & index) { callbackQCompleter_Highlighted2(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void Signal_Highlighted(const QString & text) { callbackQCompleter_Highlighted(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
QString pathFromIndex(const QModelIndex & index) const { return QString(callbackQCompleter_PathFromIndex(const_cast<MyQCompleter*>(this), this->objectName().toUtf8().data(), new QModelIndex(index))); };
QStringList splitPath(const QString & path) const { return QString(callbackQCompleter_SplitPath(const_cast<MyQCompleter*>(this), this->objectName().toUtf8().data(), path.toUtf8().data())).split("|", QString::SkipEmptyParts); };
void timerEvent(QTimerEvent * event) { callbackQCompleter_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQCompleter_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQCompleter_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQCompleter_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQCompleter_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQCompleter_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCompleter_MetaObject(const_cast<MyQCompleter*>(this), this->objectName().toUtf8().data())); };
};
int QCompleter_CaseSensitivity(void* ptr)
{
return static_cast<QCompleter*>(ptr)->caseSensitivity();
}
int QCompleter_CompletionColumn(void* ptr)
{
return static_cast<QCompleter*>(ptr)->completionColumn();
}
int QCompleter_CompletionMode(void* ptr)
{
return static_cast<QCompleter*>(ptr)->completionMode();
}
char* QCompleter_CompletionPrefix(void* ptr)
{
return static_cast<QCompleter*>(ptr)->completionPrefix().toUtf8().data();
}
int QCompleter_CompletionRole(void* ptr)
{
return static_cast<QCompleter*>(ptr)->completionRole();
}
int QCompleter_FilterMode(void* ptr)
{
return static_cast<QCompleter*>(ptr)->filterMode();
}
int QCompleter_MaxVisibleItems(void* ptr)
{
return static_cast<QCompleter*>(ptr)->maxVisibleItems();
}
int QCompleter_ModelSorting(void* ptr)
{
return static_cast<QCompleter*>(ptr)->modelSorting();
}
void QCompleter_SetCaseSensitivity(void* ptr, int 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, int 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, int 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, int sorting)
{
static_cast<QCompleter*>(ptr)->setModelSorting(static_cast<QCompleter::ModelSorting>(sorting));
}
void QCompleter_SetWrapAround(void* ptr, int wrap)
{
QMetaObject::invokeMethod(static_cast<QCompleter*>(ptr), "setWrapAround", Q_ARG(bool, wrap != 0));
}
int 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 static_cast<QCompleter*>(ptr)->currentCompletion().toUtf8().data();
}
void* QCompleter_CurrentIndex(void* ptr)
{
return new QModelIndex(static_cast<QCompleter*>(ptr)->currentIndex());
}
int QCompleter_CurrentRow(void* ptr)
{
return static_cast<QCompleter*>(ptr)->currentRow();
}
int QCompleter_Event(void* ptr, void* ev)
{
return static_cast<QCompleter*>(ptr)->event(static_cast<QEvent*>(ev));
}
int 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 static_cast<QCompleter*>(ptr)->pathFromIndex(*static_cast<QModelIndex*>(index)).toUtf8().data();
}
char* QCompleter_PathFromIndexDefault(void* ptr, void* index)
{
return static_cast<QCompleter*>(ptr)->QCompleter::pathFromIndex(*static_cast<QModelIndex*>(index)).toUtf8().data();
}
void* QCompleter_Popup(void* ptr)
{
return static_cast<QCompleter*>(ptr)->popup();
}
int 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 static_cast<QCompleter*>(ptr)->splitPath(QString(path)).join("|").toUtf8().data();
}
char* QCompleter_SplitPathDefault(void* ptr, char* path)
{
return static_cast<QCompleter*>(ptr)->QCompleter::splitPath(QString(path)).join("|").toUtf8().data();
}
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, this->objectName().toUtf8().data(), index); };
void Signal_CurrentIndexChanged(int index) { callbackQDataWidgetMapper_CurrentIndexChanged(this, this->objectName().toUtf8().data(), index); };
void revert() { callbackQDataWidgetMapper_Revert(this, this->objectName().toUtf8().data()); };
void setCurrentModelIndex(const QModelIndex & index) { callbackQDataWidgetMapper_SetCurrentModelIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
bool submit() { return callbackQDataWidgetMapper_Submit(this, this->objectName().toUtf8().data()) != 0; };
void toFirst() { callbackQDataWidgetMapper_ToFirst(this, this->objectName().toUtf8().data()); };
void toLast() { callbackQDataWidgetMapper_ToLast(this, this->objectName().toUtf8().data()); };
void toNext() { callbackQDataWidgetMapper_ToNext(this, this->objectName().toUtf8().data()); };
void toPrevious() { callbackQDataWidgetMapper_ToPrevious(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQDataWidgetMapper_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQDataWidgetMapper_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQDataWidgetMapper_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQDataWidgetMapper_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQDataWidgetMapper_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDataWidgetMapper_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQDataWidgetMapper_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQDataWidgetMapper_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDataWidgetMapper_MetaObject(const_cast<MyQDataWidgetMapper*>(this), this->objectName().toUtf8().data())); };
};
int QDataWidgetMapper_CurrentIndex(void* ptr)
{
return static_cast<QDataWidgetMapper*>(ptr)->currentIndex();
}
int 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, int aOrientation)
{
static_cast<QDataWidgetMapper*>(ptr)->setOrientation(static_cast<Qt::Orientation>(aOrientation));
}
void QDataWidgetMapper_SetSubmitPolicy(void* ptr, int policy)
{
static_cast<QDataWidgetMapper*>(ptr)->setSubmitPolicy(static_cast<QDataWidgetMapper::SubmitPolicy>(policy));
}
int 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(propertyName));
}
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 QString(static_cast<QDataWidgetMapper*>(ptr)->mappedPropertyName(static_cast<QWidget*>(widget))).toUtf8().data();
}
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));
}
int 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));
}
int QDataWidgetMapper_Event(void* ptr, void* e)
{
return static_cast<QDataWidgetMapper*>(ptr)->event(static_cast<QEvent*>(e));
}
int QDataWidgetMapper_EventDefault(void* ptr, void* e)
{
return static_cast<QDataWidgetMapper*>(ptr)->QDataWidgetMapper::event(static_cast<QEvent*>(e));
}
int QDataWidgetMapper_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QDataWidgetMapper*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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_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_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_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));
}
int QDateEdit_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QDateEdit*>(ptr)->focusNextPrevChild(next != 0);
}
int QDateEdit_FocusNextPrevChildDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QDateEdit*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QDateEdit*>(ptr)->sizeHint()).height());
}
void* QDateEdit_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDateEdit*>(ptr)->QDateEdit::sizeHint()).width(), static_cast<QSize>(static_cast<QDateEdit*>(ptr)->QDateEdit::sizeHint()).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);
}
int QDateEdit_StepEnabled(void* ptr)
{
return static_cast<QDateEdit*>(ptr)->stepEnabled();
}
int QDateEdit_StepEnabledDefault(void* ptr)
{
return static_cast<QDateEdit*>(ptr)->QDateEdit::stepEnabled();
}
char* QDateEdit_TextFromDateTime(void* ptr, void* dateTime)
{
return static_cast<QDateEdit*>(ptr)->textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8().data();
}
char* QDateEdit_TextFromDateTimeDefault(void* ptr, void* dateTime)
{
return static_cast<QDateEdit*>(ptr)->QDateEdit::textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8().data();
}
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, int query)
{
return new QVariant(static_cast<QDateEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QDateEdit_InputMethodQueryDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QDateEdit*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDateEdit*>(ptr)->minimumSizeHint()).height());
}
void* QDateEdit_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDateEdit*>(ptr)->QDateEdit::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDateEdit*>(ptr)->QDateEdit::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QDateEdit_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QDateEdit_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QDateEdit*>(ptr)->QDateEdit::setVisible(visible != 0);
}
void QDateEdit_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QDateEdit_SetWindowModifiedDefault(void* ptr, int 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));
}
int QDateEdit_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QDateEdit_CloseDefault(void* ptr)
{
return static_cast<QDateEdit*>(ptr)->QDateEdit::close();
}
int QDateEdit_HasHeightForWidth(void* ptr)
{
return static_cast<QDateEdit*>(ptr)->hasHeightForWidth();
}
int 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));
}
int QDateEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDateEdit*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QDateEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDateEdit*>(ptr)->QDateEdit::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QDateEdit_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QDateEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QDateEdit_SetHiddenDefault(void* ptr, int 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));
}
int QDateEdit_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QDateEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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 setDateTime(const QDateTime & dateTime) { callbackQDateTimeEdit_SetDateTime(this, this->objectName().toUtf8().data(), new QDateTime(dateTime)); };
void clear() { callbackQDateTimeEdit_Clear(this, this->objectName().toUtf8().data()); };
void Signal_DateTimeChanged(const QDateTime & datetime) { callbackQDateTimeEdit_DateTimeChanged(this, this->objectName().toUtf8().data(), new QDateTime(datetime)); };
QDateTime dateTimeFromText(const QString & text) const { return *static_cast<QDateTime*>(callbackQDateTimeEdit_DateTimeFromText(const_cast<MyQDateTimeEdit*>(this), this->objectName().toUtf8().data(), text.toUtf8().data())); };
void fixup(QString & input) const { callbackQDateTimeEdit_Fixup(const_cast<MyQDateTimeEdit*>(this), this->objectName().toUtf8().data(), input.toUtf8().data()); };
void focusInEvent(QFocusEvent * event) { callbackQDateTimeEdit_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQDateTimeEdit_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void keyPressEvent(QKeyEvent * event) { callbackQDateTimeEdit_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQDateTimeEdit_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQDateTimeEdit_PaintEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQDateTimeEdit_SizeHint(const_cast<MyQDateTimeEdit*>(this), this->objectName().toUtf8().data())); };
void stepBy(int steps) { callbackQDateTimeEdit_StepBy(this, this->objectName().toUtf8().data(), steps); };
StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQDateTimeEdit_StepEnabled(const_cast<MyQDateTimeEdit*>(this), this->objectName().toUtf8().data())); };
QString textFromDateTime(const QDateTime & dateTime) const { return QString(callbackQDateTimeEdit_TextFromDateTime(const_cast<MyQDateTimeEdit*>(this), this->objectName().toUtf8().data(), new QDateTime(dateTime))); };
QValidator::State validate(QString & text, int & pos) const { return static_cast<QValidator::State>(callbackQDateTimeEdit_Validate(const_cast<MyQDateTimeEdit*>(this), this->objectName().toUtf8().data(), text.toUtf8().data(), pos)); };
void wheelEvent(QWheelEvent * event) { callbackQDateTimeEdit_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void changeEvent(QEvent * event) { callbackQDateTimeEdit_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
void closeEvent(QCloseEvent * event) { callbackQDateTimeEdit_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQDateTimeEdit_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQDateTimeEdit_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQDateTimeEdit_HideEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDateTimeEdit_InputMethodQuery(const_cast<MyQDateTimeEdit*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQDateTimeEdit_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDateTimeEdit_MinimumSizeHint(const_cast<MyQDateTimeEdit*>(this), this->objectName().toUtf8().data())); };
void mouseMoveEvent(QMouseEvent * event) { callbackQDateTimeEdit_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQDateTimeEdit_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void resizeEvent(QResizeEvent * event) { callbackQDateTimeEdit_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void selectAll() { callbackQDateTimeEdit_SelectAll(this, this->objectName().toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQDateTimeEdit_ShowEvent(this, this->objectName().toUtf8().data(), event); };
void stepDown() { callbackQDateTimeEdit_StepDown(this, this->objectName().toUtf8().data()); };
void stepUp() { callbackQDateTimeEdit_StepUp(this, this->objectName().toUtf8().data()); };
void actionEvent(QActionEvent * event) { callbackQDateTimeEdit_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQDateTimeEdit_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDateTimeEdit_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQDateTimeEdit_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQDateTimeEdit_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQDateTimeEdit_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQDateTimeEdit_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQDateTimeEdit_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQDateTimeEdit_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQDateTimeEdit_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQDateTimeEdit_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQDateTimeEdit_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQDateTimeEdit_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQDateTimeEdit_Close(this, this->objectName().toUtf8().data()) != 0; };
bool hasHeightForWidth() const { return callbackQDateTimeEdit_HasHeightForWidth(const_cast<MyQDateTimeEdit*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQDateTimeEdit_HeightForWidth(const_cast<MyQDateTimeEdit*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQDateTimeEdit_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQDateTimeEdit_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQDateTimeEdit_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDateTimeEdit_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDateTimeEdit_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQDateTimeEdit_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQDateTimeEdit_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQDateTimeEdit_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQDateTimeEdit_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQDateTimeEdit_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQDateTimeEdit_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQDateTimeEdit_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQDateTimeEdit_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQDateTimeEdit_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQDateTimeEdit_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQDateTimeEdit_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQDateTimeEdit_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQDateTimeEdit_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQDateTimeEdit_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQDateTimeEdit_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQDateTimeEdit_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQDateTimeEdit_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDateTimeEdit_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQDateTimeEdit_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDateTimeEdit_MetaObject(const_cast<MyQDateTimeEdit*>(this), this->objectName().toUtf8().data())); };
};
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));
}
int 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();
}
int 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 static_cast<QDateTimeEdit*>(ptr)->displayFormat().toUtf8().data();
}
int 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, int section)
{
return static_cast<QDateTimeEdit*>(ptr)->sectionText(static_cast<QDateTimeEdit::Section>(section)).toUtf8().data();
}
void QDateTimeEdit_SetCalendarPopup(void* ptr, int enable)
{
static_cast<QDateTimeEdit*>(ptr)->setCalendarPopup(enable != 0);
}
void QDateTimeEdit_SetCurrentSection(void* ptr, int 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_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_SetTimeSpec(void* ptr, int spec)
{
static_cast<QDateTimeEdit*>(ptr)->setTimeSpec(static_cast<Qt::TimeSpec>(spec));
}
int 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_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)));
}
int QDateTimeEdit_Event(void* ptr, void* event)
{
return static_cast<QDateTimeEdit*>(ptr)->event(static_cast<QEvent*>(event));
}
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));
}
int QDateTimeEdit_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QDateTimeEdit*>(ptr)->focusNextPrevChild(next != 0);
}
int QDateTimeEdit_FocusNextPrevChildDefault(void* ptr, int 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));
}
int 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, int 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 new QSize(static_cast<QSize>(static_cast<QDateTimeEdit*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QDateTimeEdit*>(ptr)->sizeHint()).height());
}
void* QDateTimeEdit_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::sizeHint()).width(), static_cast<QSize>(static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::sizeHint()).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);
}
int QDateTimeEdit_StepEnabled(void* ptr)
{
return static_cast<QDateTimeEdit*>(ptr)->stepEnabled();
}
int QDateTimeEdit_StepEnabledDefault(void* ptr)
{
return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::stepEnabled();
}
char* QDateTimeEdit_TextFromDateTime(void* ptr, void* dateTime)
{
return static_cast<QDateTimeEdit*>(ptr)->textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8().data();
}
char* QDateTimeEdit_TextFromDateTimeDefault(void* ptr, void* dateTime)
{
return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8().data();
}
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, int query)
{
return new QVariant(static_cast<QDateTimeEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QDateTimeEdit_InputMethodQueryDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QDateTimeEdit*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDateTimeEdit*>(ptr)->minimumSizeHint()).height());
}
void* QDateTimeEdit_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QDateTimeEdit_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QDateTimeEdit_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setVisible(visible != 0);
}
void QDateTimeEdit_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QDateTimeEdit_SetWindowModifiedDefault(void* ptr, int 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));
}
int QDateTimeEdit_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QDateTimeEdit_CloseDefault(void* ptr)
{
return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::close();
}
int QDateTimeEdit_HasHeightForWidth(void* ptr)
{
return static_cast<QDateTimeEdit*>(ptr)->hasHeightForWidth();
}
int 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));
}
int QDateTimeEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDateTimeEdit*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QDateTimeEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QDateTimeEdit_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QDateTimeEdit_SetHiddenDefault(void* ptr, int 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));
}
int QDateTimeEdit_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QDateTimeEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), event); };
void Signal_PrimaryScreenChanged() { callbackQDesktopWidget_PrimaryScreenChanged(this, this->objectName().toUtf8().data()); };
void Signal_Resized(int screen) { callbackQDesktopWidget_Resized(this, this->objectName().toUtf8().data(), screen); };
void Signal_ScreenCountChanged(int newCount) { callbackQDesktopWidget_ScreenCountChanged(this, this->objectName().toUtf8().data(), newCount); };
void Signal_WorkAreaResized(int screen) { callbackQDesktopWidget_WorkAreaResized(this, this->objectName().toUtf8().data(), screen); };
void actionEvent(QActionEvent * event) { callbackQDesktopWidget_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQDesktopWidget_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDesktopWidget_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQDesktopWidget_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQDesktopWidget_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQDesktopWidget_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQDesktopWidget_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQDesktopWidget_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQDesktopWidget_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQDesktopWidget_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDesktopWidget_MinimumSizeHint(const_cast<MyQDesktopWidget*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQDesktopWidget_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQDesktopWidget_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQDesktopWidget_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQDesktopWidget_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQDesktopWidget_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQDesktopWidget_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQDesktopWidget_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQDesktopWidget_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQDesktopWidget_SizeHint(const_cast<MyQDesktopWidget*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * event) { callbackQDesktopWidget_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQDesktopWidget_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQDesktopWidget_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQDesktopWidget_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQDesktopWidget_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQDesktopWidget_HasHeightForWidth(const_cast<MyQDesktopWidget*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQDesktopWidget_HeightForWidth(const_cast<MyQDesktopWidget*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQDesktopWidget_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQDesktopWidget_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDesktopWidget_InputMethodQuery(const_cast<MyQDesktopWidget*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQDesktopWidget_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQDesktopWidget_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQDesktopWidget_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDesktopWidget_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQDesktopWidget_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQDesktopWidget_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQDesktopWidget_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDesktopWidget_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQDesktopWidget_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQDesktopWidget_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQDesktopWidget_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQDesktopWidget_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQDesktopWidget_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQDesktopWidget_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQDesktopWidget_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQDesktopWidget_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQDesktopWidget_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQDesktopWidget_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQDesktopWidget_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQDesktopWidget_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQDesktopWidget_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQDesktopWidget_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQDesktopWidget_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQDesktopWidget_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQDesktopWidget_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQDesktopWidget_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQDesktopWidget_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDesktopWidget_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQDesktopWidget_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDesktopWidget_MetaObject(const_cast<MyQDesktopWidget*>(this), this->objectName().toUtf8().data())); };
};
void* QDesktopWidget_AvailableGeometry2(void* ptr, void* widget)
{
return new QRect(static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->availableGeometry(static_cast<QWidget*>(widget))).x(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->availableGeometry(static_cast<QWidget*>(widget))).y(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->availableGeometry(static_cast<QWidget*>(widget))).width(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->availableGeometry(static_cast<QWidget*>(widget))).height());
}
void* QDesktopWidget_AvailableGeometry(void* ptr, int screen)
{
return new QRect(static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->availableGeometry(screen)).x(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->availableGeometry(screen)).y(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->availableGeometry(screen)).width(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->availableGeometry(screen)).height());
}
int 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 new QRect(static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->screenGeometry(static_cast<QWidget*>(widget))).x(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->screenGeometry(static_cast<QWidget*>(widget))).y(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->screenGeometry(static_cast<QWidget*>(widget))).width(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->screenGeometry(static_cast<QWidget*>(widget))).height());
}
void* QDesktopWidget_ScreenGeometry(void* ptr, int screen)
{
return new QRect(static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->screenGeometry(screen)).x(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->screenGeometry(screen)).y(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->screenGeometry(screen)).width(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->screenGeometry(screen)).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 new QRect(static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->availableGeometry(*static_cast<QPoint*>(p))).x(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->availableGeometry(*static_cast<QPoint*>(p))).y(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->availableGeometry(*static_cast<QPoint*>(p))).width(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->availableGeometry(*static_cast<QPoint*>(p))).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 new QRect(static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->screenGeometry(*static_cast<QPoint*>(p))).x(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->screenGeometry(*static_cast<QPoint*>(p))).y(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->screenGeometry(*static_cast<QPoint*>(p))).width(), static_cast<QRect>(static_cast<QDesktopWidget*>(ptr)->screenGeometry(*static_cast<QPoint*>(p))).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 new QSize(static_cast<QSize>(static_cast<QDesktopWidget*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDesktopWidget*>(ptr)->minimumSizeHint()).height());
}
void* QDesktopWidget_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QDesktopWidget_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QDesktopWidget_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::setVisible(visible != 0);
}
void QDesktopWidget_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QDesktopWidget_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QDesktopWidget*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QDesktopWidget*>(ptr)->sizeHint()).height());
}
void* QDesktopWidget_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::sizeHint()).width(), static_cast<QSize>(static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::sizeHint()).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));
}
int QDesktopWidget_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QDesktopWidget_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QDesktopWidget*>(ptr)->focusNextPrevChild(next != 0);
}
int QDesktopWidget_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::focusNextPrevChild(next != 0);
}
int QDesktopWidget_HasHeightForWidth(void* ptr)
{
return static_cast<QDesktopWidget*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QDesktopWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QDesktopWidget_InputMethodQueryDefault(void* ptr, int 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));
}
int QDesktopWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDesktopWidget*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QDesktopWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDesktopWidget*>(ptr)->QDesktopWidget::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QDesktopWidget_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QDesktopWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QDesktopWidget_SetHiddenDefault(void* ptr, int 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));
}
int QDesktopWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QDesktopWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), visible); };
void setWrapping(bool on) { callbackQDial_SetWrapping(this, this->objectName().toUtf8().data(), on); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDial_MinimumSizeHint(const_cast<MyQDial*>(this), this->objectName().toUtf8().data())); };
void mouseMoveEvent(QMouseEvent * e) { callbackQDial_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQDial_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQDial_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void paintEvent(QPaintEvent * pe) { callbackQDial_PaintEvent(this, this->objectName().toUtf8().data(), pe); };
void resizeEvent(QResizeEvent * e) { callbackQDial_ResizeEvent(this, this->objectName().toUtf8().data(), e); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQDial_SizeHint(const_cast<MyQDial*>(this), this->objectName().toUtf8().data())); };
void sliderChange(QAbstractSlider::SliderChange change) { callbackQDial_SliderChange(this, this->objectName().toUtf8().data(), change); };
void setOrientation(Qt::Orientation vqt) { callbackQDial_SetOrientation(this, this->objectName().toUtf8().data(), vqt); };
void setValue(int vin) { callbackQDial_SetValue(this, this->objectName().toUtf8().data(), vin); };
void changeEvent(QEvent * ev) { callbackQDial_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void keyPressEvent(QKeyEvent * ev) { callbackQDial_KeyPressEvent(this, this->objectName().toUtf8().data(), ev); };
void setRange(int min, int max) { callbackQDial_SetRange(this, this->objectName().toUtf8().data(), min, max); };
void wheelEvent(QWheelEvent * e) { callbackQDial_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void actionEvent(QActionEvent * event) { callbackQDial_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQDial_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDial_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQDial_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQDial_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQDial_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQDial_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQDial_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQDial_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQDial_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQDial_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQDial_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQDial_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQDial_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQDial_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQDial_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQDial_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQDial_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQDial_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQDial_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQDial_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQDial_HasHeightForWidth(const_cast<MyQDial*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQDial_HeightForWidth(const_cast<MyQDial*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQDial_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQDial_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDial_InputMethodQuery(const_cast<MyQDial*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQDial_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQDial_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDial_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDial_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQDial_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQDial_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQDial_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQDial_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQDial_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQDial_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQDial_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQDial_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQDial_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQDial_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQDial_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQDial_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQDial_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQDial_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQDial_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQDial_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQDial_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDial_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQDial_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDial_MetaObject(const_cast<MyQDial*>(this), this->objectName().toUtf8().data())); };
};
int QDial_NotchSize(void* ptr)
{
return static_cast<QDial*>(ptr)->notchSize();
}
double QDial_NotchTarget(void* ptr)
{
return static_cast<double>(static_cast<QDial*>(ptr)->notchTarget());
}
int QDial_NotchesVisible(void* ptr)
{
return static_cast<QDial*>(ptr)->notchesVisible();
}
void QDial_SetNotchesVisible(void* ptr, int visible)
{
QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setNotchesVisible", Q_ARG(bool, visible != 0));
}
void QDial_SetWrapping(void* ptr, int on)
{
QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setWrapping", Q_ARG(bool, on != 0));
}
int QDial_Wrapping(void* ptr)
{
return static_cast<QDial*>(ptr)->wrapping();
}
void* QDial_NewQDial(void* parent)
{
return new MyQDial(static_cast<QWidget*>(parent));
}
int 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 new QSize(static_cast<QSize>(static_cast<QDial*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDial*>(ptr)->minimumSizeHint()).height());
}
void* QDial_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDial*>(ptr)->QDial::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDial*>(ptr)->QDial::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QDial*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QDial*>(ptr)->sizeHint()).height());
}
void* QDial_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDial*>(ptr)->QDial::sizeHint()).width(), static_cast<QSize>(static_cast<QDial*>(ptr)->QDial::sizeHint()).height());
}
void QDial_SliderChange(void* ptr, int change)
{
static_cast<QDial*>(ptr)->sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
}
void QDial_SliderChangeDefault(void* ptr, int 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, int vqt)
{
QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setOrientation", Q_ARG(Qt::Orientation, static_cast<Qt::Orientation>(vqt)));
}
void QDial_SetOrientationDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QDial_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QDial_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QDial*>(ptr)->QDial::setVisible(visible != 0);
}
void QDial_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QDial_SetWindowModifiedDefault(void* ptr, int 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));
}
int QDial_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QDial_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QDial*>(ptr)->focusNextPrevChild(next != 0);
}
int QDial_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QDial*>(ptr)->QDial::focusNextPrevChild(next != 0);
}
int QDial_HasHeightForWidth(void* ptr)
{
return static_cast<QDial*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QDial*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QDial_InputMethodQueryDefault(void* ptr, int 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));
}
int QDial_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDial*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QDial_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDial*>(ptr)->QDial::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QDial_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QDial*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QDial_SetHiddenDefault(void* ptr, int 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));
}
int QDial_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QDial*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data()); };
void Signal_Accepted() { callbackQDialog_Accepted(this, this->objectName().toUtf8().data()); };
void closeEvent(QCloseEvent * e) { callbackQDialog_CloseEvent(this, this->objectName().toUtf8().data(), e); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQDialog_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
void done(int r) { callbackQDialog_Done(this, this->objectName().toUtf8().data(), r); };
int exec() { return callbackQDialog_Exec(this, this->objectName().toUtf8().data()); };
void Signal_Finished(int result) { callbackQDialog_Finished(this, this->objectName().toUtf8().data(), result); };
void keyPressEvent(QKeyEvent * e) { callbackQDialog_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDialog_MinimumSizeHint(const_cast<MyQDialog*>(this), this->objectName().toUtf8().data())); };
void open() { callbackQDialog_Open(this, this->objectName().toUtf8().data()); };
void reject() { callbackQDialog_Reject(this, this->objectName().toUtf8().data()); };
void Signal_Rejected() { callbackQDialog_Rejected(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * vqr) { callbackQDialog_ResizeEvent(this, this->objectName().toUtf8().data(), vqr); };
void setVisible(bool visible) { callbackQDialog_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void showEvent(QShowEvent * event) { callbackQDialog_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQDialog_SizeHint(const_cast<MyQDialog*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQDialog_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQDialog_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDialog_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQDialog_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQDialog_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQDialog_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQDialog_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQDialog_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQDialog_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQDialog_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQDialog_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQDialog_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQDialog_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQDialog_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setWindowModified(bool vbo) { callbackQDialog_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQDialog_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void changeEvent(QEvent * event) { callbackQDialog_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQDialog_Close(this, this->objectName().toUtf8().data()) != 0; };
bool focusNextPrevChild(bool next) { return callbackQDialog_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQDialog_HasHeightForWidth(const_cast<MyQDialog*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQDialog_HeightForWidth(const_cast<MyQDialog*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQDialog_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQDialog_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDialog_InputMethodQuery(const_cast<MyQDialog*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQDialog_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQDialog_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDialog_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQDialog_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQDialog_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQDialog_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDialog_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQDialog_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQDialog_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQDialog_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQDialog_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQDialog_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQDialog_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQDialog_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQDialog_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQDialog_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQDialog_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQDialog_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQDialog_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQDialog_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQDialog_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQDialog_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQDialog_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQDialog_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQDialog_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQDialog_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDialog_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDialog_MetaObject(const_cast<MyQDialog*>(this), this->objectName().toUtf8().data())); };
};
int QDialog_IsSizeGripEnabled(void* ptr)
{
return static_cast<QDialog*>(ptr)->isSizeGripEnabled();
}
void QDialog_SetModal(void* ptr, int 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, int vbo)
{
static_cast<QDialog*>(ptr)->setSizeGripEnabled(vbo != 0);
}
void* QDialog_NewQDialog(void* parent, int 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);
}
int QDialog_Event(void* ptr, void* e)
{
return static_cast<QDialog*>(ptr)->event(static_cast<QEvent*>(e));
}
int 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 new QSize(static_cast<QSize>(static_cast<QDialog*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDialog*>(ptr)->minimumSizeHint()).height());
}
void* QDialog_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDialog*>(ptr)->QDialog::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDialog*>(ptr)->QDialog::minimumSizeHint()).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, int visible)
{
static_cast<QDialog*>(ptr)->setVisible(visible != 0);
}
void QDialog_SetVisibleDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QDialog*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QDialog*>(ptr)->sizeHint()).height());
}
void* QDialog_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDialog*>(ptr)->QDialog::sizeHint()).width(), static_cast<QSize>(static_cast<QDialog*>(ptr)->QDialog::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QDialog_SetEnabledDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QDialog_SetWindowModifiedDefault(void* ptr, int 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));
}
int QDialog_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QDialog_CloseDefault(void* ptr)
{
return static_cast<QDialog*>(ptr)->QDialog::close();
}
int QDialog_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QDialog*>(ptr)->focusNextPrevChild(next != 0);
}
int QDialog_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QDialog*>(ptr)->QDialog::focusNextPrevChild(next != 0);
}
int QDialog_HasHeightForWidth(void* ptr)
{
return static_cast<QDialog*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QDialog*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QDialog_InputMethodQueryDefault(void* ptr, int 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));
}
int QDialog_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDialog*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QDialog_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDialog*>(ptr)->QDialog::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QDialog_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QDialog*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QDialog_SetHiddenDefault(void* ptr, int 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, this->objectName().toUtf8().data()); };
void changeEvent(QEvent * event) { callbackQDialogButtonBox_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_Clicked(QAbstractButton * button) { callbackQDialogButtonBox_Clicked(this, this->objectName().toUtf8().data(), button); };
void Signal_HelpRequested() { callbackQDialogButtonBox_HelpRequested(this, this->objectName().toUtf8().data()); };
void Signal_Rejected() { callbackQDialogButtonBox_Rejected(this, this->objectName().toUtf8().data()); };
void actionEvent(QActionEvent * event) { callbackQDialogButtonBox_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQDialogButtonBox_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDialogButtonBox_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQDialogButtonBox_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQDialogButtonBox_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQDialogButtonBox_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQDialogButtonBox_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQDialogButtonBox_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQDialogButtonBox_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQDialogButtonBox_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDialogButtonBox_MinimumSizeHint(const_cast<MyQDialogButtonBox*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQDialogButtonBox_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQDialogButtonBox_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQDialogButtonBox_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQDialogButtonBox_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQDialogButtonBox_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQDialogButtonBox_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQDialogButtonBox_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQDialogButtonBox_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQDialogButtonBox_SizeHint(const_cast<MyQDialogButtonBox*>(this), this->objectName().toUtf8().data())); };
bool close() { return callbackQDialogButtonBox_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQDialogButtonBox_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQDialogButtonBox_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQDialogButtonBox_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQDialogButtonBox_HasHeightForWidth(const_cast<MyQDialogButtonBox*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQDialogButtonBox_HeightForWidth(const_cast<MyQDialogButtonBox*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQDialogButtonBox_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQDialogButtonBox_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDialogButtonBox_InputMethodQuery(const_cast<MyQDialogButtonBox*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQDialogButtonBox_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQDialogButtonBox_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQDialogButtonBox_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDialogButtonBox_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQDialogButtonBox_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQDialogButtonBox_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQDialogButtonBox_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDialogButtonBox_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQDialogButtonBox_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQDialogButtonBox_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQDialogButtonBox_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQDialogButtonBox_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQDialogButtonBox_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQDialogButtonBox_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQDialogButtonBox_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQDialogButtonBox_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQDialogButtonBox_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQDialogButtonBox_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQDialogButtonBox_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQDialogButtonBox_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQDialogButtonBox_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQDialogButtonBox_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQDialogButtonBox_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQDialogButtonBox_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQDialogButtonBox_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQDialogButtonBox_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQDialogButtonBox_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQDialogButtonBox_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDialogButtonBox_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQDialogButtonBox_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDialogButtonBox_MetaObject(const_cast<MyQDialogButtonBox*>(this), this->objectName().toUtf8().data())); };
};
int QDialogButtonBox_CenterButtons(void* ptr)
{
return static_cast<QDialogButtonBox*>(ptr)->centerButtons();
}
int QDialogButtonBox_Orientation(void* ptr)
{
return static_cast<QDialogButtonBox*>(ptr)->orientation();
}
void QDialogButtonBox_SetCenterButtons(void* ptr, int center)
{
static_cast<QDialogButtonBox*>(ptr)->setCenterButtons(center != 0);
}
void QDialogButtonBox_SetOrientation(void* ptr, int orientation)
{
static_cast<QDialogButtonBox*>(ptr)->setOrientation(static_cast<Qt::Orientation>(orientation));
}
void QDialogButtonBox_SetStandardButtons(void* ptr, int buttons)
{
static_cast<QDialogButtonBox*>(ptr)->setStandardButtons(static_cast<QDialogButtonBox::StandardButton>(buttons));
}
int 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(int orientation, void* parent)
{
return new MyQDialogButtonBox(static_cast<Qt::Orientation>(orientation), static_cast<QWidget*>(parent));
}
void* QDialogButtonBox_NewQDialogButtonBox3(int buttons, void* parent)
{
return new MyQDialogButtonBox(static_cast<QDialogButtonBox::StandardButton>(buttons), static_cast<QWidget*>(parent));
}
void* QDialogButtonBox_NewQDialogButtonBox4(int buttons, int 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, int button)
{
return static_cast<QDialogButtonBox*>(ptr)->addButton(static_cast<QDialogButtonBox::StandardButton>(button));
}
void* QDialogButtonBox_AddButton2(void* ptr, char* text, int role)
{
return static_cast<QDialogButtonBox*>(ptr)->addButton(QString(text), static_cast<QDialogButtonBox::ButtonRole>(role));
}
void QDialogButtonBox_AddButton(void* ptr, void* button, int role)
{
static_cast<QDialogButtonBox*>(ptr)->addButton(static_cast<QAbstractButton*>(button), static_cast<QDialogButtonBox::ButtonRole>(role));
}
void* QDialogButtonBox_Button(void* ptr, int which)
{
return static_cast<QDialogButtonBox*>(ptr)->button(static_cast<QDialogButtonBox::StandardButton>(which));
}
int 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));
}
int 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));
}
int 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 new QSize(static_cast<QSize>(static_cast<QDialogButtonBox*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDialogButtonBox*>(ptr)->minimumSizeHint()).height());
}
void* QDialogButtonBox_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QDialogButtonBox_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QDialogButtonBox_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::setVisible(visible != 0);
}
void QDialogButtonBox_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QDialogButtonBox_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QDialogButtonBox*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QDialogButtonBox*>(ptr)->sizeHint()).height());
}
void* QDialogButtonBox_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::sizeHint()).width(), static_cast<QSize>(static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::sizeHint()).height());
}
int QDialogButtonBox_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QDialogButtonBox_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QDialogButtonBox*>(ptr)->focusNextPrevChild(next != 0);
}
int QDialogButtonBox_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::focusNextPrevChild(next != 0);
}
int QDialogButtonBox_HasHeightForWidth(void* ptr)
{
return static_cast<QDialogButtonBox*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QDialogButtonBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QDialogButtonBox_InputMethodQueryDefault(void* ptr, int 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));
}
int QDialogButtonBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDialogButtonBox*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QDialogButtonBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDialogButtonBox*>(ptr)->QDialogButtonBox::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QDialogButtonBox_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QDialogButtonBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QDialogButtonBox_SetHiddenDefault(void* ptr, int 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));
}
int QDialogButtonBox_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QDialogButtonBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), allowedAreas); };
void changeEvent(QEvent * event) { callbackQDockWidget_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
void closeEvent(QCloseEvent * event) { callbackQDockWidget_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_DockLocationChanged(Qt::DockWidgetArea area) { callbackQDockWidget_DockLocationChanged(this, this->objectName().toUtf8().data(), area); };
void Signal_FeaturesChanged(QDockWidget::DockWidgetFeatures features) { callbackQDockWidget_FeaturesChanged(this, this->objectName().toUtf8().data(), features); };
void paintEvent(QPaintEvent * event) { callbackQDockWidget_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_TopLevelChanged(bool topLevel) { callbackQDockWidget_TopLevelChanged(this, this->objectName().toUtf8().data(), topLevel); };
void Signal_VisibilityChanged(bool visible) { callbackQDockWidget_VisibilityChanged(this, this->objectName().toUtf8().data(), visible); };
void actionEvent(QActionEvent * event) { callbackQDockWidget_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQDockWidget_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDockWidget_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQDockWidget_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQDockWidget_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQDockWidget_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQDockWidget_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQDockWidget_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQDockWidget_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQDockWidget_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDockWidget_MinimumSizeHint(const_cast<MyQDockWidget*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQDockWidget_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQDockWidget_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQDockWidget_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQDockWidget_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQDockWidget_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQDockWidget_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQDockWidget_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQDockWidget_SizeHint(const_cast<MyQDockWidget*>(this), this->objectName().toUtf8().data())); };
bool close() { return callbackQDockWidget_Close(this, this->objectName().toUtf8().data()) != 0; };
void contextMenuEvent(QContextMenuEvent * event) { callbackQDockWidget_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQDockWidget_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQDockWidget_HasHeightForWidth(const_cast<MyQDockWidget*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQDockWidget_HeightForWidth(const_cast<MyQDockWidget*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQDockWidget_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQDockWidget_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDockWidget_InputMethodQuery(const_cast<MyQDockWidget*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQDockWidget_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQDockWidget_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQDockWidget_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDockWidget_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQDockWidget_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQDockWidget_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQDockWidget_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDockWidget_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQDockWidget_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQDockWidget_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQDockWidget_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQDockWidget_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQDockWidget_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQDockWidget_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQDockWidget_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQDockWidget_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQDockWidget_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQDockWidget_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQDockWidget_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQDockWidget_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQDockWidget_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQDockWidget_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQDockWidget_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQDockWidget_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQDockWidget_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQDockWidget_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQDockWidget_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQDockWidget_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDockWidget_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQDockWidget_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDockWidget_MetaObject(const_cast<MyQDockWidget*>(this), this->objectName().toUtf8().data())); };
};
int QDockWidget_AllowedAreas(void* ptr)
{
return static_cast<QDockWidget*>(ptr)->allowedAreas();
}
int QDockWidget_Features(void* ptr)
{
return static_cast<QDockWidget*>(ptr)->features();
}
void QDockWidget_SetAllowedAreas(void* ptr, int areas)
{
static_cast<QDockWidget*>(ptr)->setAllowedAreas(static_cast<Qt::DockWidgetArea>(areas));
}
void QDockWidget_SetFeatures(void* ptr, int features)
{
static_cast<QDockWidget*>(ptr)->setFeatures(static_cast<QDockWidget::DockWidgetFeature>(features));
}
void QDockWidget_SetFloating(void* ptr, int floating)
{
static_cast<QDockWidget*>(ptr)->setFloating(floating != 0);
}
void* QDockWidget_NewQDockWidget2(void* parent, int flags)
{
return new MyQDockWidget(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}
void* QDockWidget_NewQDockWidget(char* title, void* parent, int 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, int 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, int area)
{
static_cast<QDockWidget*>(ptr)->dockLocationChanged(static_cast<Qt::DockWidgetArea>(area));
}
int 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, int 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));
}
int QDockWidget_IsAreaAllowed(void* ptr, int area)
{
return static_cast<QDockWidget*>(ptr)->isAreaAllowed(static_cast<Qt::DockWidgetArea>(area));
}
int 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, int 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, int 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 new QSize(static_cast<QSize>(static_cast<QDockWidget*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDockWidget*>(ptr)->minimumSizeHint()).height());
}
void* QDockWidget_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDockWidget*>(ptr)->QDockWidget::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDockWidget*>(ptr)->QDockWidget::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QDockWidget_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QDockWidget_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QDockWidget*>(ptr)->QDockWidget::setVisible(visible != 0);
}
void QDockWidget_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QDockWidget_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QDockWidget*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QDockWidget*>(ptr)->sizeHint()).height());
}
void* QDockWidget_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDockWidget*>(ptr)->QDockWidget::sizeHint()).width(), static_cast<QSize>(static_cast<QDockWidget*>(ptr)->QDockWidget::sizeHint()).height());
}
int QDockWidget_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QDockWidget_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QDockWidget*>(ptr)->focusNextPrevChild(next != 0);
}
int QDockWidget_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QDockWidget*>(ptr)->QDockWidget::focusNextPrevChild(next != 0);
}
int QDockWidget_HasHeightForWidth(void* ptr)
{
return static_cast<QDockWidget*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QDockWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QDockWidget_InputMethodQueryDefault(void* ptr, int 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));
}
int QDockWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDockWidget*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QDockWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDockWidget*>(ptr)->QDockWidget::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QDockWidget_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QDockWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QDockWidget_SetHiddenDefault(void* ptr, int 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));
}
int QDockWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QDockWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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 fixup(QString & input) const { callbackQDoubleSpinBox_Fixup(const_cast<MyQDoubleSpinBox*>(this), this->objectName().toUtf8().data(), input.toUtf8().data()); };
QValidator::State validate(QString & text, int & pos) const { return static_cast<QValidator::State>(callbackQDoubleSpinBox_Validate(const_cast<MyQDoubleSpinBox*>(this), this->objectName().toUtf8().data(), text.toUtf8().data(), pos)); };
void Signal_ValueChanged2(const QString & text) { callbackQDoubleSpinBox_ValueChanged2(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void changeEvent(QEvent * event) { callbackQDoubleSpinBox_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
void clear() { callbackQDoubleSpinBox_Clear(this, this->objectName().toUtf8().data()); };
void closeEvent(QCloseEvent * event) { callbackQDoubleSpinBox_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQDoubleSpinBox_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQDoubleSpinBox_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQDoubleSpinBox_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQDoubleSpinBox_HideEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQDoubleSpinBox_InputMethodQuery(const_cast<MyQDoubleSpinBox*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQDoubleSpinBox_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQDoubleSpinBox_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQDoubleSpinBox_MinimumSizeHint(const_cast<MyQDoubleSpinBox*>(this), this->objectName().toUtf8().data())); };
void mouseMoveEvent(QMouseEvent * event) { callbackQDoubleSpinBox_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQDoubleSpinBox_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQDoubleSpinBox_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQDoubleSpinBox_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void resizeEvent(QResizeEvent * event) { callbackQDoubleSpinBox_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void selectAll() { callbackQDoubleSpinBox_SelectAll(this, this->objectName().toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQDoubleSpinBox_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQDoubleSpinBox_SizeHint(const_cast<MyQDoubleSpinBox*>(this), this->objectName().toUtf8().data())); };
void stepBy(int steps) { callbackQDoubleSpinBox_StepBy(this, this->objectName().toUtf8().data(), steps); };
void stepDown() { callbackQDoubleSpinBox_StepDown(this, this->objectName().toUtf8().data()); };
StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQDoubleSpinBox_StepEnabled(const_cast<MyQDoubleSpinBox*>(this), this->objectName().toUtf8().data())); };
void stepUp() { callbackQDoubleSpinBox_StepUp(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQDoubleSpinBox_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void actionEvent(QActionEvent * event) { callbackQDoubleSpinBox_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQDoubleSpinBox_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQDoubleSpinBox_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQDoubleSpinBox_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQDoubleSpinBox_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQDoubleSpinBox_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQDoubleSpinBox_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQDoubleSpinBox_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQDoubleSpinBox_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQDoubleSpinBox_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQDoubleSpinBox_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQDoubleSpinBox_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQDoubleSpinBox_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQDoubleSpinBox_Close(this, this->objectName().toUtf8().data()) != 0; };
bool focusNextPrevChild(bool next) { return callbackQDoubleSpinBox_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQDoubleSpinBox_HasHeightForWidth(const_cast<MyQDoubleSpinBox*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQDoubleSpinBox_HeightForWidth(const_cast<MyQDoubleSpinBox*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQDoubleSpinBox_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQDoubleSpinBox_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQDoubleSpinBox_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQDoubleSpinBox_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQDoubleSpinBox_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQDoubleSpinBox_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQDoubleSpinBox_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQDoubleSpinBox_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQDoubleSpinBox_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQDoubleSpinBox_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQDoubleSpinBox_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQDoubleSpinBox_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQDoubleSpinBox_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQDoubleSpinBox_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQDoubleSpinBox_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQDoubleSpinBox_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQDoubleSpinBox_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQDoubleSpinBox_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQDoubleSpinBox_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQDoubleSpinBox_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQDoubleSpinBox_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQDoubleSpinBox_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDoubleSpinBox_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQDoubleSpinBox_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDoubleSpinBox_MetaObject(const_cast<MyQDoubleSpinBox*>(this), this->objectName().toUtf8().data())); };
};
char* QDoubleSpinBox_CleanText(void* ptr)
{
return static_cast<QDoubleSpinBox*>(ptr)->cleanText().toUtf8().data();
}
int QDoubleSpinBox_Decimals(void* ptr)
{
return static_cast<QDoubleSpinBox*>(ptr)->decimals();
}
char* QDoubleSpinBox_Prefix(void* ptr)
{
return static_cast<QDoubleSpinBox*>(ptr)->prefix().toUtf8().data();
}
void QDoubleSpinBox_SetDecimals(void* ptr, int prec)
{
static_cast<QDoubleSpinBox*>(ptr)->setDecimals(prec);
}
void QDoubleSpinBox_SetPrefix(void* ptr, char* prefix)
{
static_cast<QDoubleSpinBox*>(ptr)->setPrefix(QString(prefix));
}
void QDoubleSpinBox_SetSuffix(void* ptr, char* suffix)
{
static_cast<QDoubleSpinBox*>(ptr)->setSuffix(QString(suffix));
}
char* QDoubleSpinBox_Suffix(void* ptr)
{
return static_cast<QDoubleSpinBox*>(ptr)->suffix().toUtf8().data();
}
void* QDoubleSpinBox_NewQDoubleSpinBox(void* parent)
{
return new MyQDoubleSpinBox(static_cast<QWidget*>(parent));
}
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_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, int query)
{
return new QVariant(static_cast<QDoubleSpinBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QDoubleSpinBox_InputMethodQueryDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QDoubleSpinBox*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDoubleSpinBox*>(ptr)->minimumSizeHint()).height());
}
void* QDoubleSpinBox_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QDoubleSpinBox*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QDoubleSpinBox*>(ptr)->sizeHint()).height());
}
void* QDoubleSpinBox_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::sizeHint()).width(), static_cast<QSize>(static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::sizeHint()).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();
}
int QDoubleSpinBox_StepEnabled(void* ptr)
{
return static_cast<QDoubleSpinBox*>(ptr)->stepEnabled();
}
int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QDoubleSpinBox_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QDoubleSpinBox_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::setVisible(visible != 0);
}
void QDoubleSpinBox_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QDoubleSpinBox_SetWindowModifiedDefault(void* ptr, int 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));
}
int QDoubleSpinBox_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QDoubleSpinBox_CloseDefault(void* ptr)
{
return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::close();
}
int QDoubleSpinBox_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QDoubleSpinBox*>(ptr)->focusNextPrevChild(next != 0);
}
int QDoubleSpinBox_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::focusNextPrevChild(next != 0);
}
int QDoubleSpinBox_HasHeightForWidth(void* ptr)
{
return static_cast<QDoubleSpinBox*>(ptr)->hasHeightForWidth();
}
int 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));
}
int QDoubleSpinBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDoubleSpinBox*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QDoubleSpinBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QDoubleSpinBox*>(ptr)->QDoubleSpinBox::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QDoubleSpinBox_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QDoubleSpinBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QDoubleSpinBox_SetHiddenDefault(void* ptr, int 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));
}
int QDoubleSpinBox_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QDoubleSpinBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), e); };
void done(int a) { callbackQErrorMessage_Done(this, this->objectName().toUtf8().data(), a); };
void showMessage(const QString & message) { callbackQErrorMessage_ShowMessage(this, this->objectName().toUtf8().data(), message.toUtf8().data()); };
void showMessage(const QString & message, const QString & ty) { callbackQErrorMessage_ShowMessage2(this, this->objectName().toUtf8().data(), message.toUtf8().data(), ty.toUtf8().data()); };
void accept() { callbackQErrorMessage_Accept(this, this->objectName().toUtf8().data()); };
void closeEvent(QCloseEvent * e) { callbackQErrorMessage_CloseEvent(this, this->objectName().toUtf8().data(), e); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQErrorMessage_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
int exec() { return callbackQErrorMessage_Exec(this, this->objectName().toUtf8().data()); };
void keyPressEvent(QKeyEvent * e) { callbackQErrorMessage_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQErrorMessage_MinimumSizeHint(const_cast<MyQErrorMessage*>(this), this->objectName().toUtf8().data())); };
void open() { callbackQErrorMessage_Open(this, this->objectName().toUtf8().data()); };
void reject() { callbackQErrorMessage_Reject(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * vqr) { callbackQErrorMessage_ResizeEvent(this, this->objectName().toUtf8().data(), vqr); };
void setVisible(bool visible) { callbackQErrorMessage_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void showEvent(QShowEvent * event) { callbackQErrorMessage_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQErrorMessage_SizeHint(const_cast<MyQErrorMessage*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQErrorMessage_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQErrorMessage_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQErrorMessage_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQErrorMessage_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQErrorMessage_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQErrorMessage_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQErrorMessage_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQErrorMessage_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQErrorMessage_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQErrorMessage_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQErrorMessage_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQErrorMessage_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQErrorMessage_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQErrorMessage_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setWindowModified(bool vbo) { callbackQErrorMessage_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQErrorMessage_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQErrorMessage_Close(this, this->objectName().toUtf8().data()) != 0; };
bool focusNextPrevChild(bool next) { return callbackQErrorMessage_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQErrorMessage_HasHeightForWidth(const_cast<MyQErrorMessage*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQErrorMessage_HeightForWidth(const_cast<MyQErrorMessage*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQErrorMessage_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQErrorMessage_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQErrorMessage_InputMethodQuery(const_cast<MyQErrorMessage*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQErrorMessage_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQErrorMessage_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQErrorMessage_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQErrorMessage_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQErrorMessage_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQErrorMessage_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQErrorMessage_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQErrorMessage_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQErrorMessage_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQErrorMessage_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQErrorMessage_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQErrorMessage_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQErrorMessage_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQErrorMessage_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQErrorMessage_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQErrorMessage_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQErrorMessage_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQErrorMessage_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQErrorMessage_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQErrorMessage_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQErrorMessage_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQErrorMessage_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQErrorMessage_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQErrorMessage_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQErrorMessage_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQErrorMessage_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQErrorMessage_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQErrorMessage_MetaObject(const_cast<MyQErrorMessage*>(this), this->objectName().toUtf8().data())); };
};
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 new QSize(static_cast<QSize>(static_cast<QErrorMessage*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QErrorMessage*>(ptr)->minimumSizeHint()).height());
}
void* QErrorMessage_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QErrorMessage*>(ptr)->QErrorMessage::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QErrorMessage*>(ptr)->QErrorMessage::minimumSizeHint()).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, int visible)
{
static_cast<QErrorMessage*>(ptr)->setVisible(visible != 0);
}
void QErrorMessage_SetVisibleDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QErrorMessage*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QErrorMessage*>(ptr)->sizeHint()).height());
}
void* QErrorMessage_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QErrorMessage*>(ptr)->QErrorMessage::sizeHint()).width(), static_cast<QSize>(static_cast<QErrorMessage*>(ptr)->QErrorMessage::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QErrorMessage_SetEnabledDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QErrorMessage_SetWindowModifiedDefault(void* ptr, int 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));
}
int QErrorMessage_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QErrorMessage_CloseDefault(void* ptr)
{
return static_cast<QErrorMessage*>(ptr)->QErrorMessage::close();
}
int QErrorMessage_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QErrorMessage*>(ptr)->focusNextPrevChild(next != 0);
}
int QErrorMessage_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QErrorMessage*>(ptr)->QErrorMessage::focusNextPrevChild(next != 0);
}
int QErrorMessage_HasHeightForWidth(void* ptr)
{
return static_cast<QErrorMessage*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QErrorMessage*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QErrorMessage_InputMethodQueryDefault(void* ptr, int 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));
}
int QErrorMessage_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QErrorMessage*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QErrorMessage_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QErrorMessage*>(ptr)->QErrorMessage::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QErrorMessage_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QErrorMessage*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QErrorMessage_SetHiddenDefault(void* ptr, int 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, this->objectName().toUtf8().data()); };
void changeEvent(QEvent * e) { callbackQFileDialog_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void Signal_CurrentChanged(const QString & path) { callbackQFileDialog_CurrentChanged(this, this->objectName().toUtf8().data(), path.toUtf8().data()); };
void Signal_CurrentUrlChanged(const QUrl & url) { callbackQFileDialog_CurrentUrlChanged(this, this->objectName().toUtf8().data(), new QUrl(url)); };
void Signal_DirectoryEntered(const QString & directory) { callbackQFileDialog_DirectoryEntered(this, this->objectName().toUtf8().data(), directory.toUtf8().data()); };
void Signal_DirectoryUrlEntered(const QUrl & directory) { callbackQFileDialog_DirectoryUrlEntered(this, this->objectName().toUtf8().data(), new QUrl(directory)); };
void done(int result) { callbackQFileDialog_Done(this, this->objectName().toUtf8().data(), result); };
void Signal_FileSelected(const QString & file) { callbackQFileDialog_FileSelected(this, this->objectName().toUtf8().data(), file.toUtf8().data()); };
void Signal_FilesSelected(const QStringList & selected) { callbackQFileDialog_FilesSelected(this, this->objectName().toUtf8().data(), selected.join("|").toUtf8().data()); };
void Signal_FilterSelected(const QString & filter) { callbackQFileDialog_FilterSelected(this, this->objectName().toUtf8().data(), filter.toUtf8().data()); };
void setVisible(bool visible) { callbackQFileDialog_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void Signal_UrlSelected(const QUrl & url) { callbackQFileDialog_UrlSelected(this, this->objectName().toUtf8().data(), new QUrl(url)); };
void closeEvent(QCloseEvent * e) { callbackQFileDialog_CloseEvent(this, this->objectName().toUtf8().data(), e); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQFileDialog_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
int exec() { return callbackQFileDialog_Exec(this, this->objectName().toUtf8().data()); };
void keyPressEvent(QKeyEvent * e) { callbackQFileDialog_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQFileDialog_MinimumSizeHint(const_cast<MyQFileDialog*>(this), this->objectName().toUtf8().data())); };
void reject() { callbackQFileDialog_Reject(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * vqr) { callbackQFileDialog_ResizeEvent(this, this->objectName().toUtf8().data(), vqr); };
void showEvent(QShowEvent * event) { callbackQFileDialog_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQFileDialog_SizeHint(const_cast<MyQFileDialog*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQFileDialog_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQFileDialog_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQFileDialog_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQFileDialog_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQFileDialog_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQFileDialog_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQFileDialog_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQFileDialog_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQFileDialog_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQFileDialog_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQFileDialog_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQFileDialog_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQFileDialog_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQFileDialog_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setWindowModified(bool vbo) { callbackQFileDialog_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQFileDialog_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQFileDialog_Close(this, this->objectName().toUtf8().data()) != 0; };
bool focusNextPrevChild(bool next) { return callbackQFileDialog_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQFileDialog_HasHeightForWidth(const_cast<MyQFileDialog*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQFileDialog_HeightForWidth(const_cast<MyQFileDialog*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQFileDialog_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQFileDialog_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQFileDialog_InputMethodQuery(const_cast<MyQFileDialog*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQFileDialog_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQFileDialog_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQFileDialog_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQFileDialog_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQFileDialog_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQFileDialog_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQFileDialog_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQFileDialog_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQFileDialog_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQFileDialog_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQFileDialog_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQFileDialog_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQFileDialog_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQFileDialog_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQFileDialog_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQFileDialog_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQFileDialog_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQFileDialog_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQFileDialog_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQFileDialog_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQFileDialog_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQFileDialog_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQFileDialog_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQFileDialog_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQFileDialog_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQFileDialog_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQFileDialog_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFileDialog_MetaObject(const_cast<MyQFileDialog*>(this), this->objectName().toUtf8().data())); };
};
void* QFileDialog_NewQFileDialog(void* parent, int flags)
{
return new MyQFileDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}
int QFileDialog_AcceptMode(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->acceptMode();
}
int QFileDialog_ConfirmOverwrite(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->confirmOverwrite();
}
char* QFileDialog_DefaultSuffix(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->defaultSuffix().toUtf8().data();
}
int QFileDialog_FileMode(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->fileMode();
}
int QFileDialog_IsNameFilterDetailsVisible(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->isNameFilterDetailsVisible();
}
int QFileDialog_IsReadOnly(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->isReadOnly();
}
int QFileDialog_Options(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->options();
}
int QFileDialog_ResolveSymlinks(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->resolveSymlinks();
}
void QFileDialog_SetAcceptMode(void* ptr, int mode)
{
static_cast<QFileDialog*>(ptr)->setAcceptMode(static_cast<QFileDialog::AcceptMode>(mode));
}
void QFileDialog_SetConfirmOverwrite(void* ptr, int 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, int mode)
{
static_cast<QFileDialog*>(ptr)->setFileMode(static_cast<QFileDialog::FileMode>(mode));
}
void QFileDialog_SetNameFilterDetailsVisible(void* ptr, int enabled)
{
static_cast<QFileDialog*>(ptr)->setNameFilterDetailsVisible(enabled != 0);
}
void QFileDialog_SetOptions(void* ptr, int options)
{
static_cast<QFileDialog*>(ptr)->setOptions(static_cast<QFileDialog::Option>(options));
}
void QFileDialog_SetReadOnly(void* ptr, int enabled)
{
static_cast<QFileDialog*>(ptr)->setReadOnly(enabled != 0);
}
void QFileDialog_SetResolveSymlinks(void* ptr, int 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, int mode)
{
static_cast<QFileDialog*>(ptr)->setViewMode(static_cast<QFileDialog::ViewMode>(mode));
}
char* QFileDialog_SupportedSchemes(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->supportedSchemes().join("|").toUtf8().data();
}
int 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));
}
int 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, int options)
{
return QFileDialog::getExistingDirectory(static_cast<QWidget*>(parent), QString(caption), QString(dir), static_cast<QFileDialog::Option>(options)).toUtf8().data();
}
void* QFileDialog_QFileDialog_GetExistingDirectoryUrl(void* parent, char* caption, void* dir, int 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, int options)
{
return QFileDialog::getOpenFileName(static_cast<QWidget*>(parent), QString(caption), QString(dir), QString(filter), new QString(selectedFilter), static_cast<QFileDialog::Option>(options)).toUtf8().data();
}
char* QFileDialog_QFileDialog_GetOpenFileNames(void* parent, char* caption, char* dir, char* filter, char* selectedFilter, int options)
{
return QFileDialog::getOpenFileNames(static_cast<QWidget*>(parent), QString(caption), QString(dir), QString(filter), new QString(selectedFilter), static_cast<QFileDialog::Option>(options)).join("|").toUtf8().data();
}
void* QFileDialog_QFileDialog_GetOpenFileUrl(void* parent, char* caption, void* dir, char* filter, char* selectedFilter, int 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, int options)
{
return QFileDialog::getSaveFileName(static_cast<QWidget*>(parent), QString(caption), QString(dir), QString(filter), new QString(selectedFilter), static_cast<QFileDialog::Option>(options)).toUtf8().data();
}
void* QFileDialog_QFileDialog_GetSaveFileUrl(void* parent, char* caption, void* dir, char* filter, char* selectedFilter, int 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 static_cast<QFileDialog*>(ptr)->history().join("|").toUtf8().data();
}
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, int label)
{
return static_cast<QFileDialog*>(ptr)->labelText(static_cast<QFileDialog::DialogLabel>(label)).toUtf8().data();
}
char* QFileDialog_MimeTypeFilters(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->mimeTypeFilters().join("|").toUtf8().data();
}
char* QFileDialog_NameFilters(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->nameFilters().join("|").toUtf8().data();
}
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();
}
int QFileDialog_RestoreState(void* ptr, char* state)
{
return static_cast<QFileDialog*>(ptr)->restoreState(QByteArray(state));
}
char* QFileDialog_SaveState(void* ptr)
{
return QString(static_cast<QFileDialog*>(ptr)->saveState()).toUtf8().data();
}
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 static_cast<QFileDialog*>(ptr)->selectedFiles().join("|").toUtf8().data();
}
char* QFileDialog_SelectedNameFilter(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->selectedNameFilter().toUtf8().data();
}
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, int 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, int 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, int option, int 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, int visible)
{
static_cast<QFileDialog*>(ptr)->setVisible(visible != 0);
}
void QFileDialog_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QFileDialog*>(ptr)->QFileDialog::setVisible(visible != 0);
}
int QFileDialog_TestOption(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QFileDialog*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QFileDialog*>(ptr)->minimumSizeHint()).height());
}
void* QFileDialog_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFileDialog*>(ptr)->QFileDialog::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QFileDialog*>(ptr)->QFileDialog::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QFileDialog*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QFileDialog*>(ptr)->sizeHint()).height());
}
void* QFileDialog_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFileDialog*>(ptr)->QFileDialog::sizeHint()).width(), static_cast<QSize>(static_cast<QFileDialog*>(ptr)->QFileDialog::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QFileDialog_SetEnabledDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QFileDialog_SetWindowModifiedDefault(void* ptr, int 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));
}
int QFileDialog_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QFileDialog_CloseDefault(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->QFileDialog::close();
}
int QFileDialog_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QFileDialog*>(ptr)->focusNextPrevChild(next != 0);
}
int QFileDialog_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QFileDialog*>(ptr)->QFileDialog::focusNextPrevChild(next != 0);
}
int QFileDialog_HasHeightForWidth(void* ptr)
{
return static_cast<QFileDialog*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QFileDialog*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QFileDialog_InputMethodQueryDefault(void* ptr, int 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));
}
int QFileDialog_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QFileDialog*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QFileDialog_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QFileDialog*>(ptr)->QFileDialog::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QFileDialog_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QFileDialog*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QFileDialog_SetHiddenDefault(void* ptr, int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQFileIconProvider() : QFileIconProvider() {};
QIcon icon(QFileIconProvider::IconType ty) const { return *static_cast<QIcon*>(callbackQFileIconProvider_Icon(const_cast<MyQFileIconProvider*>(this), this->objectNameAbs().toUtf8().data(), ty)); };
QIcon icon(const QFileInfo & info) const { return *static_cast<QIcon*>(callbackQFileIconProvider_Icon2(const_cast<MyQFileIconProvider*>(this), this->objectNameAbs().toUtf8().data(), new QFileInfo(info))); };
QString type(const QFileInfo & info) const { return QString(callbackQFileIconProvider_Type(const_cast<MyQFileIconProvider*>(this), this->objectNameAbs().toUtf8().data(), new QFileInfo(info))); };
};
void* QFileIconProvider_NewQFileIconProvider()
{
return new MyQFileIconProvider();
}
void* QFileIconProvider_Icon(void* ptr, int ty)
{
return new QIcon(static_cast<QFileIconProvider*>(ptr)->icon(static_cast<QFileIconProvider::IconType>(ty)));
}
void* QFileIconProvider_IconDefault(void* ptr, int 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)));
}
int QFileIconProvider_Options(void* ptr)
{
return static_cast<QFileIconProvider*>(ptr)->options();
}
void QFileIconProvider_SetOptions(void* ptr, int options)
{
static_cast<QFileIconProvider*>(ptr)->setOptions(static_cast<QFileIconProvider::Option>(options));
}
char* QFileIconProvider_Type(void* ptr, void* info)
{
return static_cast<QFileIconProvider*>(ptr)->type(*static_cast<QFileInfo*>(info)).toUtf8().data();
}
char* QFileIconProvider_TypeDefault(void* ptr, void* info)
{
return static_cast<QFileIconProvider*>(ptr)->QFileIconProvider::type(*static_cast<QFileInfo*>(info)).toUtf8().data();
}
void QFileIconProvider_DestroyQFileIconProvider(void* ptr)
{
static_cast<QFileIconProvider*>(ptr)->~QFileIconProvider();
}
char* QFileIconProvider_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQFileIconProvider*>(static_cast<QFileIconProvider*>(ptr))) {
return static_cast<MyQFileIconProvider*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QFileIconProvider_BASE").toUtf8().data();
}
void QFileIconProvider_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQFileIconProvider*>(static_cast<QFileIconProvider*>(ptr))) {
static_cast<MyQFileIconProvider*>(ptr)->setObjectNameAbs(QString(name));
}
}
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, this->objectName().toUtf8().data(), path.toUtf8().data()); };
void Signal_FileRenamed(const QString & path, const QString & oldName, const QString & newName) { callbackQFileSystemModel_FileRenamed(this, this->objectName().toUtf8().data(), path.toUtf8().data(), oldName.toUtf8().data(), newName.toUtf8().data()); };
void Signal_RootPathChanged(const QString & newPath) { callbackQFileSystemModel_RootPathChanged(this, this->objectName().toUtf8().data(), newPath.toUtf8().data()); };
QModelIndex sibling(int row, int column, const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQFileSystemModel_Sibling(const_cast<MyQFileSystemModel*>(this), this->objectName().toUtf8().data(), row, column, new QModelIndex(index))); };
QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQFileSystemModel_Buddy(const_cast<MyQFileSystemModel*>(this), this->objectName().toUtf8().data(), new 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), this->objectName().toUtf8().data(), const_cast<QMimeData*>(data), action, row, column, new QModelIndex(parent)) != 0; };
bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQFileSystemModel_InsertColumns(this, this->objectName().toUtf8().data(), column, count, new QModelIndex(parent)) != 0; };
bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQFileSystemModel_InsertRows(this, this->objectName().toUtf8().data(), row, count, new QModelIndex(parent)) != 0; };
bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQFileSystemModel_MoveColumns(this, this->objectName().toUtf8().data(), new QModelIndex(sourceParent), sourceColumn, count, new QModelIndex(destinationParent), destinationChild) != 0; };
bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQFileSystemModel_MoveRows(this, this->objectName().toUtf8().data(), new QModelIndex(sourceParent), sourceRow, count, new QModelIndex(destinationParent), destinationChild) != 0; };
bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQFileSystemModel_RemoveColumns(this, this->objectName().toUtf8().data(), column, count, new QModelIndex(parent)) != 0; };
bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQFileSystemModel_RemoveRows(this, this->objectName().toUtf8().data(), row, count, new QModelIndex(parent)) != 0; };
void resetInternalData() { callbackQFileSystemModel_ResetInternalData(this, this->objectName().toUtf8().data()); };
void revert() { callbackQFileSystemModel_Revert(this, this->objectName().toUtf8().data()); };
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQFileSystemModel_SetHeaderData(this, this->objectName().toUtf8().data(), section, orientation, new QVariant(value), role) != 0; };
QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQFileSystemModel_Span(const_cast<MyQFileSystemModel*>(this), this->objectName().toUtf8().data(), new QModelIndex(index))); };
bool submit() { return callbackQFileSystemModel_Submit(this, this->objectName().toUtf8().data()) != 0; };
Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQFileSystemModel_SupportedDragActions(const_cast<MyQFileSystemModel*>(this), this->objectName().toUtf8().data())); };
void childEvent(QChildEvent * event) { callbackQFileSystemModel_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQFileSystemModel_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQFileSystemModel_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQFileSystemModel_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQFileSystemModel_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQFileSystemModel_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFileSystemModel_MetaObject(const_cast<MyQFileSystemModel*>(this), this->objectName().toUtf8().data())); };
};
void* QFileSystemModel_FileInfo(void* ptr, void* index)
{
return new QFileInfo(static_cast<QFileSystemModel*>(ptr)->fileInfo(*static_cast<QModelIndex*>(index)));
}
int QFileSystemModel_IsReadOnly(void* ptr)
{
return static_cast<QFileSystemModel*>(ptr)->isReadOnly();
}
int QFileSystemModel_NameFilterDisables(void* ptr)
{
return static_cast<QFileSystemModel*>(ptr)->nameFilterDisables();
}
int QFileSystemModel_Remove(void* ptr, void* index)
{
return static_cast<QFileSystemModel*>(ptr)->remove(*static_cast<QModelIndex*>(index));
}
int QFileSystemModel_ResolveSymlinks(void* ptr)
{
return static_cast<QFileSystemModel*>(ptr)->resolveSymlinks();
}
int QFileSystemModel_Rmdir(void* ptr, void* index)
{
return static_cast<QFileSystemModel*>(ptr)->rmdir(*static_cast<QModelIndex*>(index));
}
void QFileSystemModel_SetNameFilterDisables(void* ptr, int enable)
{
static_cast<QFileSystemModel*>(ptr)->setNameFilterDisables(enable != 0);
}
void QFileSystemModel_SetReadOnly(void* ptr, int enable)
{
static_cast<QFileSystemModel*>(ptr)->setReadOnly(enable != 0);
}
void QFileSystemModel_SetResolveSymlinks(void* ptr, int enable)
{
static_cast<QFileSystemModel*>(ptr)->setResolveSymlinks(enable != 0);
}
void* QFileSystemModel_NewQFileSystemModel(void* parent)
{
return new MyQFileSystemModel(static_cast<QObject*>(parent));
}
int 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));
}
int QFileSystemModel_DropMimeData(void* ptr, void* data, int 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));
}
int 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 static_cast<QFileSystemModel*>(ptr)->fileName(*static_cast<QModelIndex*>(index)).toUtf8().data();
}
char* QFileSystemModel_FilePath(void* ptr, void* index)
{
return static_cast<QFileSystemModel*>(ptr)->filePath(*static_cast<QModelIndex*>(index)).toUtf8().data();
}
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));
}
int QFileSystemModel_Filter(void* ptr)
{
return static_cast<QFileSystemModel*>(ptr)->filter();
}
int QFileSystemModel_Flags(void* ptr, void* index)
{
return static_cast<QFileSystemModel*>(ptr)->flags(*static_cast<QModelIndex*>(index));
}
int QFileSystemModel_HasChildren(void* ptr, void* parent)
{
return static_cast<QFileSystemModel*>(ptr)->hasChildren(*static_cast<QModelIndex*>(parent));
}
void* QFileSystemModel_HeaderData(void* ptr, int section, int 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)));
}
int 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 static_cast<QFileSystemModel*>(ptr)->mimeTypes().join("|").toUtf8().data();
}
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 static_cast<QFileSystemModel*>(ptr)->nameFilters().join("|").toUtf8().data();
}
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 static_cast<QFileSystemModel*>(ptr)->rootPath().toUtf8().data();
}
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));
}
int 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, int 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)));
}
long long QFileSystemModel_Size(void* ptr, void* index)
{
return static_cast<long long>(static_cast<QFileSystemModel*>(ptr)->size(*static_cast<QModelIndex*>(index)));
}
void QFileSystemModel_Sort(void* ptr, int column, int order)
{
static_cast<QFileSystemModel*>(ptr)->sort(column, static_cast<Qt::SortOrder>(order));
}
int 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 static_cast<QFileSystemModel*>(ptr)->type(*static_cast<QModelIndex*>(index)).toUtf8().data();
}
void QFileSystemModel_DestroyQFileSystemModel(void* ptr)
{
static_cast<QFileSystemModel*>(ptr)->~QFileSystemModel();
}
void* QFileSystemModel_Sibling(void* ptr, int row, int column, void* index)
{
return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->sibling(row, column, *static_cast<QModelIndex*>(index)));
}
void* QFileSystemModel_SiblingDefault(void* ptr, int row, int column, void* index)
{
return new QModelIndex(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::sibling(row, column, *static_cast<QModelIndex*>(index)));
}
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)));
}
int QFileSystemModel_CanDropMimeData(void* ptr, void* data, int 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));
}
int QFileSystemModel_CanDropMimeDataDefault(void* ptr, void* data, int 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));
}
int QFileSystemModel_InsertColumns(void* ptr, int column, int count, void* parent)
{
return static_cast<QFileSystemModel*>(ptr)->insertColumns(column, count, *static_cast<QModelIndex*>(parent));
}
int QFileSystemModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent)
{
return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
}
int QFileSystemModel_InsertRows(void* ptr, int row, int count, void* parent)
{
return static_cast<QFileSystemModel*>(ptr)->insertRows(row, count, *static_cast<QModelIndex*>(parent));
}
int QFileSystemModel_InsertRowsDefault(void* ptr, int row, int count, void* parent)
{
return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
}
int 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);
}
int 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);
}
int 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);
}
int 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);
}
int QFileSystemModel_RemoveColumns(void* ptr, int column, int count, void* parent)
{
return static_cast<QFileSystemModel*>(ptr)->removeColumns(column, count, *static_cast<QModelIndex*>(parent));
}
int QFileSystemModel_RemoveColumnsDefault(void* ptr, int column, int count, void* parent)
{
return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
}
int QFileSystemModel_RemoveRows(void* ptr, int row, int count, void* parent)
{
return static_cast<QFileSystemModel*>(ptr)->removeRows(row, count, *static_cast<QModelIndex*>(parent));
}
int 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();
}
int QFileSystemModel_SetHeaderData(void* ptr, int section, int orientation, void* value, int role)
{
return static_cast<QFileSystemModel*>(ptr)->setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
}
int QFileSystemModel_SetHeaderDataDefault(void* ptr, int section, int 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 new QSize(static_cast<QSize>(static_cast<QFileSystemModel*>(ptr)->span(*static_cast<QModelIndex*>(index))).width(), static_cast<QSize>(static_cast<QFileSystemModel*>(ptr)->span(*static_cast<QModelIndex*>(index))).height());
}
void* QFileSystemModel_SpanDefault(void* ptr, void* index)
{
return new QSize(static_cast<QSize>(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::span(*static_cast<QModelIndex*>(index))).width(), static_cast<QSize>(static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::span(*static_cast<QModelIndex*>(index))).height());
}
int QFileSystemModel_Submit(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QFileSystemModel*>(ptr), "submit", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QFileSystemModel_SubmitDefault(void* ptr)
{
return static_cast<QFileSystemModel*>(ptr)->QFileSystemModel::submit();
}
int QFileSystemModel_SupportedDragActions(void* ptr)
{
return static_cast<QFileSystemModel*>(ptr)->supportedDragActions();
}
int 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));
}
int QFileSystemModel_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QFileSystemModel*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), vqp); };
void actionEvent(QActionEvent * event) { callbackQFocusFrame_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQFocusFrame_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQFocusFrame_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQFocusFrame_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQFocusFrame_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQFocusFrame_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQFocusFrame_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQFocusFrame_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQFocusFrame_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQFocusFrame_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQFocusFrame_MinimumSizeHint(const_cast<MyQFocusFrame*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQFocusFrame_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQFocusFrame_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQFocusFrame_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQFocusFrame_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQFocusFrame_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQFocusFrame_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQFocusFrame_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQFocusFrame_SizeHint(const_cast<MyQFocusFrame*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * event) { callbackQFocusFrame_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQFocusFrame_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQFocusFrame_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQFocusFrame_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQFocusFrame_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQFocusFrame_HasHeightForWidth(const_cast<MyQFocusFrame*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQFocusFrame_HeightForWidth(const_cast<MyQFocusFrame*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQFocusFrame_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQFocusFrame_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQFocusFrame_InputMethodQuery(const_cast<MyQFocusFrame*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQFocusFrame_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQFocusFrame_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQFocusFrame_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQFocusFrame_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQFocusFrame_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQFocusFrame_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQFocusFrame_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQFocusFrame_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQFocusFrame_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQFocusFrame_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQFocusFrame_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQFocusFrame_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQFocusFrame_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQFocusFrame_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQFocusFrame_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQFocusFrame_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQFocusFrame_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQFocusFrame_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQFocusFrame_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQFocusFrame_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQFocusFrame_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQFocusFrame_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQFocusFrame_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQFocusFrame_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQFocusFrame_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQFocusFrame_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQFocusFrame_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQFocusFrame_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQFocusFrame_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFocusFrame_MetaObject(const_cast<MyQFocusFrame*>(this), this->objectName().toUtf8().data())); };
};
void* QFocusFrame_NewQFocusFrame(void* parent)
{
return new MyQFocusFrame(static_cast<QWidget*>(parent));
}
int QFocusFrame_Event(void* ptr, void* e)
{
return static_cast<QFocusFrame*>(ptr)->event(static_cast<QEvent*>(e));
}
int 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 new QSize(static_cast<QSize>(static_cast<QFocusFrame*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QFocusFrame*>(ptr)->minimumSizeHint()).height());
}
void* QFocusFrame_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFocusFrame*>(ptr)->QFocusFrame::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QFocusFrame*>(ptr)->QFocusFrame::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QFocusFrame_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QFocusFrame_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QFocusFrame*>(ptr)->QFocusFrame::setVisible(visible != 0);
}
void QFocusFrame_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QFocusFrame_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QFocusFrame*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QFocusFrame*>(ptr)->sizeHint()).height());
}
void* QFocusFrame_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFocusFrame*>(ptr)->QFocusFrame::sizeHint()).width(), static_cast<QSize>(static_cast<QFocusFrame*>(ptr)->QFocusFrame::sizeHint()).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));
}
int QFocusFrame_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QFocusFrame_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QFocusFrame*>(ptr)->focusNextPrevChild(next != 0);
}
int QFocusFrame_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QFocusFrame*>(ptr)->QFocusFrame::focusNextPrevChild(next != 0);
}
int QFocusFrame_HasHeightForWidth(void* ptr)
{
return static_cast<QFocusFrame*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QFocusFrame*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QFocusFrame_InputMethodQueryDefault(void* ptr, int 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));
}
int QFocusFrame_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QFocusFrame*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QFocusFrame_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QFocusFrame*>(ptr)->QFocusFrame::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QFocusFrame_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QFocusFrame*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QFocusFrame_SetHiddenDefault(void* ptr, int 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, this->objectName().toUtf8().data(), new QFont(f)); };
void Signal_CurrentFontChanged(const QFont & font) { callbackQFontComboBox_CurrentFontChanged(this, this->objectName().toUtf8().data(), new QFont(font)); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQFontComboBox_SizeHint(const_cast<MyQFontComboBox*>(this), this->objectName().toUtf8().data())); };
void setCurrentIndex(int index) { callbackQFontComboBox_SetCurrentIndex(this, this->objectName().toUtf8().data(), index); };
void setCurrentText(const QString & text) { callbackQFontComboBox_SetCurrentText(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void changeEvent(QEvent * e) { callbackQFontComboBox_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void clear() { callbackQFontComboBox_Clear(this, this->objectName().toUtf8().data()); };
void clearEditText() { callbackQFontComboBox_ClearEditText(this, this->objectName().toUtf8().data()); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQFontComboBox_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
void focusInEvent(QFocusEvent * e) { callbackQFontComboBox_FocusInEvent(this, this->objectName().toUtf8().data(), e); };
void focusOutEvent(QFocusEvent * e) { callbackQFontComboBox_FocusOutEvent(this, this->objectName().toUtf8().data(), e); };
void hideEvent(QHideEvent * e) { callbackQFontComboBox_HideEvent(this, this->objectName().toUtf8().data(), e); };
void hidePopup() { callbackQFontComboBox_HidePopup(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * e) { callbackQFontComboBox_InputMethodEvent(this, this->objectName().toUtf8().data(), e); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQFontComboBox_InputMethodQuery(const_cast<MyQFontComboBox*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * e) { callbackQFontComboBox_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void keyReleaseEvent(QKeyEvent * e) { callbackQFontComboBox_KeyReleaseEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQFontComboBox_MinimumSizeHint(const_cast<MyQFontComboBox*>(this), this->objectName().toUtf8().data())); };
void mousePressEvent(QMouseEvent * e) { callbackQFontComboBox_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQFontComboBox_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void paintEvent(QPaintEvent * e) { callbackQFontComboBox_PaintEvent(this, this->objectName().toUtf8().data(), e); };
void resizeEvent(QResizeEvent * e) { callbackQFontComboBox_ResizeEvent(this, this->objectName().toUtf8().data(), e); };
void setEditText(const QString & text) { callbackQFontComboBox_SetEditText(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void showEvent(QShowEvent * e) { callbackQFontComboBox_ShowEvent(this, this->objectName().toUtf8().data(), e); };
void showPopup() { callbackQFontComboBox_ShowPopup(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * e) { callbackQFontComboBox_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void actionEvent(QActionEvent * event) { callbackQFontComboBox_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQFontComboBox_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQFontComboBox_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQFontComboBox_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQFontComboBox_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQFontComboBox_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQFontComboBox_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQFontComboBox_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQFontComboBox_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQFontComboBox_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQFontComboBox_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQFontComboBox_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQFontComboBox_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQFontComboBox_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQFontComboBox_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQFontComboBox_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQFontComboBox_HasHeightForWidth(const_cast<MyQFontComboBox*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQFontComboBox_HeightForWidth(const_cast<MyQFontComboBox*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQFontComboBox_Hide(this, this->objectName().toUtf8().data()); };
void lower() { callbackQFontComboBox_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQFontComboBox_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQFontComboBox_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQFontComboBox_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQFontComboBox_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQFontComboBox_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQFontComboBox_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQFontComboBox_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQFontComboBox_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQFontComboBox_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQFontComboBox_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQFontComboBox_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQFontComboBox_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQFontComboBox_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQFontComboBox_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQFontComboBox_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQFontComboBox_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQFontComboBox_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQFontComboBox_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQFontComboBox_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQFontComboBox_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQFontComboBox_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQFontComboBox_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQFontComboBox_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFontComboBox_MetaObject(const_cast<MyQFontComboBox*>(this), this->objectName().toUtf8().data())); };
};
void* QFontComboBox_CurrentFont(void* ptr)
{
return new QFont(static_cast<QFontComboBox*>(ptr)->currentFont());
}
int 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, int filters)
{
static_cast<QFontComboBox*>(ptr)->setFontFilters(static_cast<QFontComboBox::FontFilter>(filters));
}
void QFontComboBox_SetWritingSystem(void* ptr, int vqf)
{
static_cast<QFontComboBox*>(ptr)->setWritingSystem(static_cast<QFontDatabase::WritingSystem>(vqf));
}
int 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));
}
int QFontComboBox_Event(void* ptr, void* e)
{
return static_cast<QFontComboBox*>(ptr)->event(static_cast<QEvent*>(e));
}
void* QFontComboBox_SizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFontComboBox*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QFontComboBox*>(ptr)->sizeHint()).height());
}
void* QFontComboBox_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFontComboBox*>(ptr)->QFontComboBox::sizeHint()).width(), static_cast<QSize>(static_cast<QFontComboBox*>(ptr)->QFontComboBox::sizeHint()).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, int query)
{
return new QVariant(static_cast<QFontComboBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QFontComboBox_InputMethodQueryDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QFontComboBox*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QFontComboBox*>(ptr)->minimumSizeHint()).height());
}
void* QFontComboBox_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFontComboBox*>(ptr)->QFontComboBox::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QFontComboBox*>(ptr)->QFontComboBox::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QFontComboBox_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QFontComboBox_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QFontComboBox*>(ptr)->QFontComboBox::setVisible(visible != 0);
}
void QFontComboBox_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QFontComboBox_SetWindowModifiedDefault(void* ptr, int 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));
}
int QFontComboBox_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QFontComboBox_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QFontComboBox*>(ptr)->focusNextPrevChild(next != 0);
}
int QFontComboBox_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QFontComboBox*>(ptr)->QFontComboBox::focusNextPrevChild(next != 0);
}
int QFontComboBox_HasHeightForWidth(void* ptr)
{
return static_cast<QFontComboBox*>(ptr)->hasHeightForWidth();
}
int 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));
}
int QFontComboBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QFontComboBox*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QFontComboBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QFontComboBox*>(ptr)->QFontComboBox::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QFontComboBox_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QFontComboBox_SetHiddenDefault(void* ptr, int 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));
}
int QFontComboBox_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QFontComboBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), e); };
void Signal_CurrentFontChanged(const QFont & font) { callbackQFontDialog_CurrentFontChanged(this, this->objectName().toUtf8().data(), new QFont(font)); };
void done(int result) { callbackQFontDialog_Done(this, this->objectName().toUtf8().data(), result); };
void Signal_FontSelected(const QFont & font) { callbackQFontDialog_FontSelected(this, this->objectName().toUtf8().data(), new QFont(font)); };
void setVisible(bool visible) { callbackQFontDialog_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void accept() { callbackQFontDialog_Accept(this, this->objectName().toUtf8().data()); };
void closeEvent(QCloseEvent * e) { callbackQFontDialog_CloseEvent(this, this->objectName().toUtf8().data(), e); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQFontDialog_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
int exec() { return callbackQFontDialog_Exec(this, this->objectName().toUtf8().data()); };
void keyPressEvent(QKeyEvent * e) { callbackQFontDialog_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQFontDialog_MinimumSizeHint(const_cast<MyQFontDialog*>(this), this->objectName().toUtf8().data())); };
void reject() { callbackQFontDialog_Reject(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * vqr) { callbackQFontDialog_ResizeEvent(this, this->objectName().toUtf8().data(), vqr); };
void showEvent(QShowEvent * event) { callbackQFontDialog_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQFontDialog_SizeHint(const_cast<MyQFontDialog*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQFontDialog_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQFontDialog_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQFontDialog_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQFontDialog_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQFontDialog_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQFontDialog_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQFontDialog_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQFontDialog_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQFontDialog_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQFontDialog_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQFontDialog_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQFontDialog_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQFontDialog_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQFontDialog_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setWindowModified(bool vbo) { callbackQFontDialog_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQFontDialog_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQFontDialog_Close(this, this->objectName().toUtf8().data()) != 0; };
bool focusNextPrevChild(bool next) { return callbackQFontDialog_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQFontDialog_HasHeightForWidth(const_cast<MyQFontDialog*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQFontDialog_HeightForWidth(const_cast<MyQFontDialog*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQFontDialog_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQFontDialog_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQFontDialog_InputMethodQuery(const_cast<MyQFontDialog*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQFontDialog_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQFontDialog_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQFontDialog_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQFontDialog_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQFontDialog_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQFontDialog_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQFontDialog_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQFontDialog_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQFontDialog_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQFontDialog_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQFontDialog_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQFontDialog_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQFontDialog_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQFontDialog_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQFontDialog_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQFontDialog_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQFontDialog_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQFontDialog_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQFontDialog_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQFontDialog_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQFontDialog_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQFontDialog_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQFontDialog_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQFontDialog_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQFontDialog_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQFontDialog_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQFontDialog_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFontDialog_MetaObject(const_cast<MyQFontDialog*>(this), this->objectName().toUtf8().data())); };
};
int QFontDialog_Options(void* ptr)
{
return static_cast<QFontDialog*>(ptr)->options();
}
void QFontDialog_SetOptions(void* ptr, int 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(int ok, void* parent)
{
return new QFont(QFontDialog::getFont(NULL, static_cast<QWidget*>(parent)));
}
void* QFontDialog_QFontDialog_GetFont(int ok, void* initial, void* parent, char* title, int 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, int option, int on)
{
static_cast<QFontDialog*>(ptr)->setOption(static_cast<QFontDialog::FontDialogOption>(option), on != 0);
}
void QFontDialog_SetVisible(void* ptr, int visible)
{
static_cast<QFontDialog*>(ptr)->setVisible(visible != 0);
}
void QFontDialog_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QFontDialog*>(ptr)->QFontDialog::setVisible(visible != 0);
}
int QFontDialog_TestOption(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QFontDialog*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QFontDialog*>(ptr)->minimumSizeHint()).height());
}
void* QFontDialog_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFontDialog*>(ptr)->QFontDialog::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QFontDialog*>(ptr)->QFontDialog::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QFontDialog*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QFontDialog*>(ptr)->sizeHint()).height());
}
void* QFontDialog_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFontDialog*>(ptr)->QFontDialog::sizeHint()).width(), static_cast<QSize>(static_cast<QFontDialog*>(ptr)->QFontDialog::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QFontDialog_SetEnabledDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QFontDialog_SetWindowModifiedDefault(void* ptr, int 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));
}
int QFontDialog_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QFontDialog_CloseDefault(void* ptr)
{
return static_cast<QFontDialog*>(ptr)->QFontDialog::close();
}
int QFontDialog_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QFontDialog*>(ptr)->focusNextPrevChild(next != 0);
}
int QFontDialog_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QFontDialog*>(ptr)->QFontDialog::focusNextPrevChild(next != 0);
}
int QFontDialog_HasHeightForWidth(void* ptr)
{
return static_cast<QFontDialog*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QFontDialog*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QFontDialog_InputMethodQueryDefault(void* ptr, int 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));
}
int QFontDialog_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QFontDialog*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QFontDialog_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QFontDialog*>(ptr)->QFontDialog::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QFontDialog_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QFontDialog*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QFontDialog_SetHiddenDefault(void* ptr, int 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, this->objectName().toUtf8().data(), item); };
int count() const { return callbackQFormLayout_Count(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data()); };
Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQFormLayout_ExpandingDirections(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data())); };
bool hasHeightForWidth() const { return callbackQFormLayout_HasHeightForWidth(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int width) const { return callbackQFormLayout_HeightForWidth(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data(), width); };
void invalidate() { callbackQFormLayout_Invalidate(this, this->objectName().toUtf8().data()); };
QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQFormLayout_ItemAt2(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data(), index)); };
QSize minimumSize() const { return *static_cast<QSize*>(callbackQFormLayout_MinimumSize(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data())); };
void setGeometry(const QRect & rect) { callbackQFormLayout_SetGeometry(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height())); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQFormLayout_SizeHint(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data())); };
QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQFormLayout_TakeAt(this, this->objectName().toUtf8().data(), index)); };
QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQFormLayout_ControlTypes(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data())); };
QRect geometry() const { return *static_cast<QRect*>(callbackQFormLayout_Geometry(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data())); };
int indexOf(QWidget * widget) const { return callbackQFormLayout_IndexOf(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data(), widget); };
bool isEmpty() const { return callbackQFormLayout_IsEmpty(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data()) != 0; };
QLayout * layout() { return static_cast<QLayout*>(callbackQFormLayout_Layout(this, this->objectName().toUtf8().data())); };
QSize maximumSize() const { return *static_cast<QSize*>(callbackQFormLayout_MaximumSize(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data())); };
void timerEvent(QTimerEvent * event) { callbackQFormLayout_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQFormLayout_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQFormLayout_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQFormLayout_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQFormLayout_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQFormLayout_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQFormLayout_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFormLayout_MetaObject(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data())); };
int minimumHeightForWidth(int w) const { return callbackQFormLayout_MinimumHeightForWidth(const_cast<MyQFormLayout*>(this), this->objectName().toUtf8().data(), w); };
QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQFormLayout_SpacerItem(this, this->objectName().toUtf8().data())); };
QWidget * widget() { return static_cast<QWidget*>(callbackQFormLayout_Widget(this, this->objectName().toUtf8().data())); };
};
int QFormLayout_FieldGrowthPolicy(void* ptr)
{
return static_cast<QFormLayout*>(ptr)->fieldGrowthPolicy();
}
int QFormLayout_FormAlignment(void* ptr)
{
return static_cast<QFormLayout*>(ptr)->formAlignment();
}
int QFormLayout_HorizontalSpacing(void* ptr)
{
return static_cast<QFormLayout*>(ptr)->horizontalSpacing();
}
int QFormLayout_LabelAlignment(void* ptr)
{
return static_cast<QFormLayout*>(ptr)->labelAlignment();
}
int QFormLayout_RowWrapPolicy(void* ptr)
{
return static_cast<QFormLayout*>(ptr)->rowWrapPolicy();
}
void QFormLayout_SetFieldGrowthPolicy(void* ptr, int policy)
{
static_cast<QFormLayout*>(ptr)->setFieldGrowthPolicy(static_cast<QFormLayout::FieldGrowthPolicy>(policy));
}
void QFormLayout_SetFormAlignment(void* ptr, int 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, int alignment)
{
static_cast<QFormLayout*>(ptr)->setLabelAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}
void QFormLayout_SetRowWrapPolicy(void* ptr, int 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();
}
int QFormLayout_ExpandingDirections(void* ptr)
{
return static_cast<QFormLayout*>(ptr)->expandingDirections();
}
int QFormLayout_ExpandingDirectionsDefault(void* ptr)
{
return static_cast<QFormLayout*>(ptr)->QFormLayout::expandingDirections();
}
int QFormLayout_HasHeightForWidth(void* ptr)
{
return static_cast<QFormLayout*>(ptr)->hasHeightForWidth();
}
int 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, int 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 new QSize(static_cast<QSize>(static_cast<QFormLayout*>(ptr)->minimumSize()).width(), static_cast<QSize>(static_cast<QFormLayout*>(ptr)->minimumSize()).height());
}
void* QFormLayout_MinimumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFormLayout*>(ptr)->QFormLayout::minimumSize()).width(), static_cast<QSize>(static_cast<QFormLayout*>(ptr)->QFormLayout::minimumSize()).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, int 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, int 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, int role, void* widget)
{
static_cast<QFormLayout*>(ptr)->setWidget(row, static_cast<QFormLayout::ItemRole>(role), static_cast<QWidget*>(widget));
}
void* QFormLayout_SizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFormLayout*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QFormLayout*>(ptr)->sizeHint()).height());
}
void* QFormLayout_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFormLayout*>(ptr)->QFormLayout::sizeHint()).width(), static_cast<QSize>(static_cast<QFormLayout*>(ptr)->QFormLayout::sizeHint()).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();
}
int QFormLayout_ControlTypes(void* ptr)
{
return static_cast<QFormLayout*>(ptr)->controlTypes();
}
int QFormLayout_ControlTypesDefault(void* ptr)
{
return static_cast<QFormLayout*>(ptr)->QFormLayout::controlTypes();
}
void* QFormLayout_Geometry(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QFormLayout*>(ptr)->geometry()).x(), static_cast<QRect>(static_cast<QFormLayout*>(ptr)->geometry()).y(), static_cast<QRect>(static_cast<QFormLayout*>(ptr)->geometry()).width(), static_cast<QRect>(static_cast<QFormLayout*>(ptr)->geometry()).height());
}
void* QFormLayout_GeometryDefault(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QFormLayout*>(ptr)->QFormLayout::geometry()).x(), static_cast<QRect>(static_cast<QFormLayout*>(ptr)->QFormLayout::geometry()).y(), static_cast<QRect>(static_cast<QFormLayout*>(ptr)->QFormLayout::geometry()).width(), static_cast<QRect>(static_cast<QFormLayout*>(ptr)->QFormLayout::geometry()).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));
}
int QFormLayout_IsEmpty(void* ptr)
{
return static_cast<QFormLayout*>(ptr)->isEmpty();
}
int 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 new QSize(static_cast<QSize>(static_cast<QFormLayout*>(ptr)->maximumSize()).width(), static_cast<QSize>(static_cast<QFormLayout*>(ptr)->maximumSize()).height());
}
void* QFormLayout_MaximumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFormLayout*>(ptr)->QFormLayout::maximumSize()).width(), static_cast<QSize>(static_cast<QFormLayout*>(ptr)->QFormLayout::maximumSize()).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));
}
int QFormLayout_Event(void* ptr, void* e)
{
return static_cast<QFormLayout*>(ptr)->event(static_cast<QEvent*>(e));
}
int QFormLayout_EventDefault(void* ptr, void* e)
{
return static_cast<QFormLayout*>(ptr)->QFormLayout::event(static_cast<QEvent*>(e));
}
int QFormLayout_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QFormLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), ev); };
void paintEvent(QPaintEvent * vqp) { callbackQFrame_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQFrame_SizeHint(const_cast<MyQFrame*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQFrame_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQFrame_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQFrame_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQFrame_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQFrame_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQFrame_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQFrame_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQFrame_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQFrame_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQFrame_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQFrame_MinimumSizeHint(const_cast<MyQFrame*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQFrame_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQFrame_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQFrame_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQFrame_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQFrame_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQFrame_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQFrame_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQFrame_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQFrame_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQFrame_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQFrame_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQFrame_HasHeightForWidth(const_cast<MyQFrame*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQFrame_HeightForWidth(const_cast<MyQFrame*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQFrame_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQFrame_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQFrame_InputMethodQuery(const_cast<MyQFrame*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQFrame_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQFrame_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQFrame_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQFrame_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQFrame_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQFrame_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQFrame_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQFrame_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQFrame_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQFrame_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQFrame_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQFrame_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQFrame_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQFrame_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQFrame_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQFrame_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQFrame_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQFrame_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQFrame_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQFrame_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQFrame_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQFrame_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQFrame_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQFrame_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQFrame_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQFrame_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQFrame_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQFrame_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQFrame_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQFrame_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQFrame_MetaObject(const_cast<MyQFrame*>(this), this->objectName().toUtf8().data())); };
};
void* QFrame_FrameRect(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QFrame*>(ptr)->frameRect()).x(), static_cast<QRect>(static_cast<QFrame*>(ptr)->frameRect()).y(), static_cast<QRect>(static_cast<QFrame*>(ptr)->frameRect()).width(), static_cast<QRect>(static_cast<QFrame*>(ptr)->frameRect()).height());
}
int QFrame_FrameShadow(void* ptr)
{
return static_cast<QFrame*>(ptr)->frameShadow();
}
int 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, int vsh)
{
static_cast<QFrame*>(ptr)->setFrameShadow(static_cast<QFrame::Shadow>(vsh));
}
void QFrame_SetFrameShape(void* ptr, int 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, int 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));
}
int 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 new QSize(static_cast<QSize>(static_cast<QFrame*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QFrame*>(ptr)->sizeHint()).height());
}
void* QFrame_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFrame*>(ptr)->QFrame::sizeHint()).width(), static_cast<QSize>(static_cast<QFrame*>(ptr)->QFrame::sizeHint()).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 new QSize(static_cast<QSize>(static_cast<QFrame*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QFrame*>(ptr)->minimumSizeHint()).height());
}
void* QFrame_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QFrame*>(ptr)->QFrame::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QFrame*>(ptr)->QFrame::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QFrame_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QFrame_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QFrame*>(ptr)->QFrame::setVisible(visible != 0);
}
void QFrame_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QFrame_SetWindowModifiedDefault(void* ptr, int 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));
}
int QFrame_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QFrame_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QFrame*>(ptr)->focusNextPrevChild(next != 0);
}
int QFrame_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QFrame*>(ptr)->QFrame::focusNextPrevChild(next != 0);
}
int QFrame_HasHeightForWidth(void* ptr)
{
return static_cast<QFrame*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QFrame*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QFrame_InputMethodQueryDefault(void* ptr, int 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));
}
int QFrame_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QFrame*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QFrame_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QFrame*>(ptr)->QFrame::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QFrame_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QFrame*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QFrame_SetHiddenDefault(void* ptr, int 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));
}
int QFrame_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QFrame*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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());
}
int QGesture_GestureCancelPolicy(void* ptr)
{
return static_cast<QGesture*>(ptr)->gestureCancelPolicy();
}
int QGesture_GestureType(void* ptr)
{
return static_cast<QGesture*>(ptr)->gestureType();
}
int QGesture_HasHotSpot(void* ptr)
{
return static_cast<QGesture*>(ptr)->hasHotSpot();
}
void* QGesture_HotSpot(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGesture*>(ptr)->hotSpot()).x(), static_cast<QPointF>(static_cast<QGesture*>(ptr)->hotSpot()).y());
}
void QGesture_SetGestureCancelPolicy(void* ptr, int 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));
}
int 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));
}
int QGesture_Event(void* ptr, void* e)
{
return static_cast<QGesture*>(ptr)->event(static_cast<QEvent*>(e));
}
int QGesture_EventDefault(void* ptr, void* e)
{
return static_cast<QGesture*>(ptr)->QGesture::event(static_cast<QEvent*>(e));
}
int QGesture_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGesture*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, int gestureType)
{
static_cast<QGestureEvent*>(ptr)->accept(static_cast<Qt::GestureType>(gestureType));
}
void* QGestureEvent_Gesture(void* ptr, int 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, int gestureType)
{
static_cast<QGestureEvent*>(ptr)->ignore(static_cast<Qt::GestureType>(gestureType));
}
int QGestureEvent_IsAccepted(void* ptr, void* gesture)
{
return static_cast<QGestureEvent*>(ptr)->isAccepted(static_cast<QGesture*>(gesture));
}
int QGestureEvent_IsAccepted2(void* ptr, int gestureType)
{
return static_cast<QGestureEvent*>(ptr)->isAccepted(static_cast<Qt::GestureType>(gestureType));
}
void* QGestureEvent_MapToGraphicsScene(void* ptr, void* gesturePoint)
{
return new QPointF(static_cast<QPointF>(static_cast<QGestureEvent*>(ptr)->mapToGraphicsScene(*static_cast<QPointF*>(gesturePoint))).x(), static_cast<QPointF>(static_cast<QGestureEvent*>(ptr)->mapToGraphicsScene(*static_cast<QPointF*>(gesturePoint))).y());
}
void QGestureEvent_SetAccepted(void* ptr, void* gesture, int value)
{
static_cast<QGestureEvent*>(ptr)->setAccepted(static_cast<QGesture*>(gesture), value != 0);
}
void QGestureEvent_SetAccepted2(void* ptr, int gestureType, int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQGestureRecognizer() : QGestureRecognizer() {};
QGesture * create(QObject * target) { return static_cast<QGesture*>(callbackQGestureRecognizer_Create(this, this->objectNameAbs().toUtf8().data(), target)); };
Result recognize(QGesture * gesture, QObject * watched, QEvent * event) { return static_cast<QGestureRecognizer::ResultFlag>(callbackQGestureRecognizer_Recognize(this, this->objectNameAbs().toUtf8().data(), gesture, watched, event)); };
void reset(QGesture * gesture) { callbackQGestureRecognizer_Reset(this, this->objectNameAbs().toUtf8().data(), gesture); };
};
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));
}
int 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));
}
int 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(int ty)
{
QGestureRecognizer::unregisterRecognizer(static_cast<Qt::GestureType>(ty));
}
void QGestureRecognizer_DestroyQGestureRecognizer(void* ptr)
{
static_cast<QGestureRecognizer*>(ptr)->~QGestureRecognizer();
}
char* QGestureRecognizer_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGestureRecognizer*>(static_cast<QGestureRecognizer*>(ptr))) {
return static_cast<MyQGestureRecognizer*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGestureRecognizer_BASE").toUtf8().data();
}
void QGestureRecognizer_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGestureRecognizer*>(static_cast<QGestureRecognizer*>(ptr))) {
static_cast<MyQGestureRecognizer*>(ptr)->setObjectNameAbs(QString(name));
}
}
void QGraphicsAnchor_SetSizePolicy(void* ptr, int policy)
{
static_cast<QGraphicsAnchor*>(ptr)->setSizePolicy(static_cast<QSizePolicy::Policy>(policy));
}
void QGraphicsAnchor_SetSpacing(void* ptr, double spacing)
{
static_cast<QGraphicsAnchor*>(ptr)->setSpacing(static_cast<double>(spacing));
}
int QGraphicsAnchor_SizePolicy(void* ptr)
{
return static_cast<QGraphicsAnchor*>(ptr)->sizePolicy();
}
double QGraphicsAnchor_Spacing(void* ptr)
{
return static_cast<double>(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));
}
int QGraphicsAnchor_Event(void* ptr, void* e)
{
return static_cast<QGraphicsAnchor*>(ptr)->event(static_cast<QEvent*>(e));
}
int QGraphicsAnchor_EventDefault(void* ptr, void* e)
{
return static_cast<QGraphicsAnchor*>(ptr)->QGraphicsAnchor::event(static_cast<QEvent*>(e));
}
int QGraphicsAnchor_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsAnchor*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQGraphicsAnchorLayout(QGraphicsLayoutItem *parent) : QGraphicsAnchorLayout(parent) {};
int count() const { return callbackQGraphicsAnchorLayout_Count(const_cast<MyQGraphicsAnchorLayout*>(this), this->objectNameAbs().toUtf8().data()); };
void invalidate() { callbackQGraphicsAnchorLayout_Invalidate(this, this->objectNameAbs().toUtf8().data()); };
QGraphicsLayoutItem * itemAt(int index) const { return static_cast<QGraphicsLayoutItem*>(callbackQGraphicsAnchorLayout_ItemAt(const_cast<MyQGraphicsAnchorLayout*>(this), this->objectNameAbs().toUtf8().data(), index)); };
void removeAt(int index) { callbackQGraphicsAnchorLayout_RemoveAt(this, this->objectNameAbs().toUtf8().data(), index); };
void setGeometry(const QRectF & geom) { callbackQGraphicsAnchorLayout_SetGeometry(this, this->objectNameAbs().toUtf8().data(), new QRectF(static_cast<QRectF>(geom).x(), static_cast<QRectF>(geom).y(), static_cast<QRectF>(geom).width(), static_cast<QRectF>(geom).height())); };
QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsAnchorLayout_SizeHint(const_cast<MyQGraphicsAnchorLayout*>(this), this->objectNameAbs().toUtf8().data(), which, new QSizeF(static_cast<QSizeF>(constraint).width(), static_cast<QSizeF>(constraint).height()))); };
void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsAnchorLayout_GetContentsMargins(const_cast<MyQGraphicsAnchorLayout*>(this), this->objectNameAbs().toUtf8().data(), *static_cast<double*>(left), *static_cast<double*>(top), *static_cast<double*>(right), *static_cast<double*>(bottom)); };
void updateGeometry() { callbackQGraphicsAnchorLayout_UpdateGeometry(this, this->objectNameAbs().toUtf8().data()); };
void widgetEvent(QEvent * e) { callbackQGraphicsAnchorLayout_WidgetEvent(this, this->objectNameAbs().toUtf8().data(), e); };
};
void* QGraphicsAnchorLayout_NewQGraphicsAnchorLayout(void* parent)
{
return new MyQGraphicsAnchorLayout(static_cast<QGraphicsLayoutItem*>(parent));
}
void* QGraphicsAnchorLayout_AddAnchor(void* ptr, void* firstItem, int firstEdge, void* secondItem, int 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, int 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, int firstCorner, void* secondItem, int 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, int firstEdge, void* secondItem, int 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<double>(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(static_cast<double>(spacing));
}
void QGraphicsAnchorLayout_SetSpacing(void* ptr, double spacing)
{
static_cast<QGraphicsAnchorLayout*>(ptr)->setSpacing(static_cast<double>(spacing));
}
void QGraphicsAnchorLayout_SetVerticalSpacing(void* ptr, double spacing)
{
static_cast<QGraphicsAnchorLayout*>(ptr)->setVerticalSpacing(static_cast<double>(spacing));
}
void* QGraphicsAnchorLayout_SizeHint(void* ptr, int which, void* constraint)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsAnchorLayout*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).width(), static_cast<QSizeF>(static_cast<QGraphicsAnchorLayout*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).height());
}
void* QGraphicsAnchorLayout_SizeHintDefault(void* ptr, int which, void* constraint)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).width(), static_cast<QSizeF>(static_cast<QGraphicsAnchorLayout*>(ptr)->QGraphicsAnchorLayout::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).height());
}
double QGraphicsAnchorLayout_VerticalSpacing(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsAnchorLayout*>(ptr)->verticalSpacing());
}
void QGraphicsAnchorLayout_DestroyQGraphicsAnchorLayout(void* ptr)
{
static_cast<QGraphicsAnchorLayout*>(ptr)->~QGraphicsAnchorLayout();
}
char* QGraphicsAnchorLayout_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsAnchorLayout*>(static_cast<QGraphicsAnchorLayout*>(ptr))) {
return static_cast<MyQGraphicsAnchorLayout*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsAnchorLayout_BASE").toUtf8().data();
}
void QGraphicsAnchorLayout_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsAnchorLayout*>(static_cast<QGraphicsAnchorLayout*>(ptr))) {
static_cast<MyQGraphicsAnchorLayout*>(ptr)->setObjectNameAbs(QString(name));
}
}
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, this->objectName().toUtf8().data(), hints); };
void setBlurRadius(qreal blurRadius) { callbackQGraphicsBlurEffect_SetBlurRadius(this, this->objectName().toUtf8().data(), static_cast<double>(blurRadius)); };
void Signal_BlurHintsChanged(QGraphicsBlurEffect::BlurHints hints) { callbackQGraphicsBlurEffect_BlurHintsChanged(this, this->objectName().toUtf8().data(), hints); };
void Signal_BlurRadiusChanged(qreal radius) { callbackQGraphicsBlurEffect_BlurRadiusChanged(this, this->objectName().toUtf8().data(), static_cast<double>(radius)); };
QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsBlurEffect_BoundingRectFor(const_cast<MyQGraphicsBlurEffect*>(this), this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height()))); };
void draw(QPainter * painter) { callbackQGraphicsBlurEffect_Draw(this, this->objectName().toUtf8().data(), painter); };
void setEnabled(bool enable) { callbackQGraphicsBlurEffect_SetEnabled(this, this->objectName().toUtf8().data(), enable); };
void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsBlurEffect_SourceChanged(this, this->objectName().toUtf8().data(), flags); };
void update() { callbackQGraphicsBlurEffect_Update(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsBlurEffect_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsBlurEffect_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsBlurEffect_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsBlurEffect_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsBlurEffect_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsBlurEffect_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQGraphicsBlurEffect_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsBlurEffect_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsBlurEffect_MetaObject(const_cast<MyQGraphicsBlurEffect*>(this), this->objectName().toUtf8().data())); };
};
int QGraphicsBlurEffect_BlurHints(void* ptr)
{
return static_cast<QGraphicsBlurEffect*>(ptr)->blurHints();
}
double QGraphicsBlurEffect_BlurRadius(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsBlurEffect*>(ptr)->blurRadius());
}
void QGraphicsBlurEffect_SetBlurHints(void* ptr, int 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, static_cast<double>(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, int 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(static_cast<double>(radius));
}
void* QGraphicsBlurEffect_BoundingRectFor(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsBlurEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsBlurEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsBlurEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsBlurEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).height());
}
void* QGraphicsBlurEffect_BoundingRectForDefault(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::boundingRectFor(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::boundingRectFor(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::boundingRectFor(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::boundingRectFor(*static_cast<QRectF*>(rect))).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, int enable)
{
QMetaObject::invokeMethod(static_cast<QGraphicsBlurEffect*>(ptr), "setEnabled", Q_ARG(bool, enable != 0));
}
void QGraphicsBlurEffect_SetEnabledDefault(void* ptr, int enable)
{
static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::setEnabled(enable != 0);
}
void QGraphicsBlurEffect_SourceChanged(void* ptr, int flags)
{
static_cast<QGraphicsBlurEffect*>(ptr)->sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}
void QGraphicsBlurEffect_SourceChangedDefault(void* ptr, int 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));
}
int QGraphicsBlurEffect_Event(void* ptr, void* e)
{
return static_cast<QGraphicsBlurEffect*>(ptr)->event(static_cast<QEvent*>(e));
}
int QGraphicsBlurEffect_EventDefault(void* ptr, void* e)
{
return static_cast<QGraphicsBlurEffect*>(ptr)->QGraphicsBlurEffect::event(static_cast<QEvent*>(e));
}
int QGraphicsBlurEffect_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsBlurEffect*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), new QColor(c)); };
void setStrength(qreal strength) { callbackQGraphicsColorizeEffect_SetStrength(this, this->objectName().toUtf8().data(), static_cast<double>(strength)); };
void Signal_ColorChanged(const QColor & color) { callbackQGraphicsColorizeEffect_ColorChanged(this, this->objectName().toUtf8().data(), new QColor(color)); };
void draw(QPainter * painter) { callbackQGraphicsColorizeEffect_Draw(this, this->objectName().toUtf8().data(), painter); };
void Signal_StrengthChanged(qreal strength) { callbackQGraphicsColorizeEffect_StrengthChanged(this, this->objectName().toUtf8().data(), static_cast<double>(strength)); };
void setEnabled(bool enable) { callbackQGraphicsColorizeEffect_SetEnabled(this, this->objectName().toUtf8().data(), enable); };
QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsColorizeEffect_BoundingRectFor(const_cast<MyQGraphicsColorizeEffect*>(this), this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height()))); };
void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsColorizeEffect_SourceChanged(this, this->objectName().toUtf8().data(), flags); };
void update() { callbackQGraphicsColorizeEffect_Update(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsColorizeEffect_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsColorizeEffect_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsColorizeEffect_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsColorizeEffect_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsColorizeEffect_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsColorizeEffect_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQGraphicsColorizeEffect_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsColorizeEffect_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsColorizeEffect_MetaObject(const_cast<MyQGraphicsColorizeEffect*>(this), this->objectName().toUtf8().data())); };
};
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, static_cast<double>(strength)));
}
double QGraphicsColorizeEffect_Strength(void* ptr)
{
return static_cast<double>(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(static_cast<double>(strength));
}
void QGraphicsColorizeEffect_DestroyQGraphicsColorizeEffect(void* ptr)
{
static_cast<QGraphicsColorizeEffect*>(ptr)->~QGraphicsColorizeEffect();
}
void QGraphicsColorizeEffect_SetEnabled(void* ptr, int enable)
{
QMetaObject::invokeMethod(static_cast<QGraphicsColorizeEffect*>(ptr), "setEnabled", Q_ARG(bool, enable != 0));
}
void QGraphicsColorizeEffect_SetEnabledDefault(void* ptr, int enable)
{
static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::setEnabled(enable != 0);
}
void* QGraphicsColorizeEffect_BoundingRectFor(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsColorizeEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsColorizeEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsColorizeEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsColorizeEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).height());
}
void* QGraphicsColorizeEffect_BoundingRectForDefault(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::boundingRectFor(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::boundingRectFor(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::boundingRectFor(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::boundingRectFor(*static_cast<QRectF*>(rect))).height());
}
void QGraphicsColorizeEffect_SourceChanged(void* ptr, int flags)
{
static_cast<QGraphicsColorizeEffect*>(ptr)->sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}
void QGraphicsColorizeEffect_SourceChangedDefault(void* ptr, int 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));
}
int QGraphicsColorizeEffect_Event(void* ptr, void* e)
{
return static_cast<QGraphicsColorizeEffect*>(ptr)->event(static_cast<QEvent*>(e));
}
int QGraphicsColorizeEffect_EventDefault(void* ptr, void* e)
{
return static_cast<QGraphicsColorizeEffect*>(ptr)->QGraphicsColorizeEffect::event(static_cast<QEvent*>(e));
}
int QGraphicsColorizeEffect_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsColorizeEffect*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), static_cast<double>(blurRadius)); };
void setColor(const QColor & color) { callbackQGraphicsDropShadowEffect_SetColor(this, this->objectName().toUtf8().data(), new QColor(color)); };
void setOffset(const QPointF & ofs) { callbackQGraphicsDropShadowEffect_SetOffset(this, this->objectName().toUtf8().data(), new QPointF(static_cast<QPointF>(ofs).x(), static_cast<QPointF>(ofs).y())); };
void Signal_BlurRadiusChanged(qreal blurRadius) { callbackQGraphicsDropShadowEffect_BlurRadiusChanged(this, this->objectName().toUtf8().data(), static_cast<double>(blurRadius)); };
QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsDropShadowEffect_BoundingRectFor(const_cast<MyQGraphicsDropShadowEffect*>(this), this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height()))); };
void Signal_ColorChanged(const QColor & color) { callbackQGraphicsDropShadowEffect_ColorChanged(this, this->objectName().toUtf8().data(), new QColor(color)); };
void draw(QPainter * painter) { callbackQGraphicsDropShadowEffect_Draw(this, this->objectName().toUtf8().data(), painter); };
void Signal_OffsetChanged(const QPointF & offset) { callbackQGraphicsDropShadowEffect_OffsetChanged(this, this->objectName().toUtf8().data(), new QPointF(static_cast<QPointF>(offset).x(), static_cast<QPointF>(offset).y())); };
void setOffset(qreal d) { callbackQGraphicsDropShadowEffect_SetOffset2(this, this->objectName().toUtf8().data(), static_cast<double>(d)); };
void setOffset(qreal dx, qreal dy) { callbackQGraphicsDropShadowEffect_SetOffset3(this, this->objectName().toUtf8().data(), static_cast<double>(dx), static_cast<double>(dy)); };
void setXOffset(qreal dx) { callbackQGraphicsDropShadowEffect_SetXOffset(this, this->objectName().toUtf8().data(), static_cast<double>(dx)); };
void setYOffset(qreal dy) { callbackQGraphicsDropShadowEffect_SetYOffset(this, this->objectName().toUtf8().data(), static_cast<double>(dy)); };
void setEnabled(bool enable) { callbackQGraphicsDropShadowEffect_SetEnabled(this, this->objectName().toUtf8().data(), enable); };
void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsDropShadowEffect_SourceChanged(this, this->objectName().toUtf8().data(), flags); };
void update() { callbackQGraphicsDropShadowEffect_Update(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsDropShadowEffect_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsDropShadowEffect_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsDropShadowEffect_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsDropShadowEffect_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsDropShadowEffect_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsDropShadowEffect_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQGraphicsDropShadowEffect_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsDropShadowEffect_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsDropShadowEffect_MetaObject(const_cast<MyQGraphicsDropShadowEffect*>(this), this->objectName().toUtf8().data())); };
};
double QGraphicsDropShadowEffect_BlurRadius(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsDropShadowEffect*>(ptr)->blurRadius());
}
void* QGraphicsDropShadowEffect_Color(void* ptr)
{
return new QColor(static_cast<QGraphicsDropShadowEffect*>(ptr)->color());
}
void* QGraphicsDropShadowEffect_Offset(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsDropShadowEffect*>(ptr)->offset()).x(), static_cast<QPointF>(static_cast<QGraphicsDropShadowEffect*>(ptr)->offset()).y());
}
void QGraphicsDropShadowEffect_SetBlurRadius(void* ptr, double blurRadius)
{
QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setBlurRadius", Q_ARG(qreal, static_cast<double>(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(static_cast<double>(blurRadius));
}
void* QGraphicsDropShadowEffect_BoundingRectFor(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsDropShadowEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsDropShadowEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsDropShadowEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsDropShadowEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).height());
}
void* QGraphicsDropShadowEffect_BoundingRectForDefault(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::boundingRectFor(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::boundingRectFor(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::boundingRectFor(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::boundingRectFor(*static_cast<QRectF*>(rect))).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, static_cast<double>(d)));
}
void QGraphicsDropShadowEffect_SetOffset3(void* ptr, double dx, double dy)
{
QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setOffset", Q_ARG(qreal, static_cast<double>(dx)), Q_ARG(qreal, static_cast<double>(dy)));
}
void QGraphicsDropShadowEffect_SetXOffset(void* ptr, double dx)
{
QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setXOffset", Q_ARG(qreal, static_cast<double>(dx)));
}
void QGraphicsDropShadowEffect_SetYOffset(void* ptr, double dy)
{
QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setYOffset", Q_ARG(qreal, static_cast<double>(dy)));
}
double QGraphicsDropShadowEffect_XOffset(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsDropShadowEffect*>(ptr)->xOffset());
}
double QGraphicsDropShadowEffect_YOffset(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsDropShadowEffect*>(ptr)->yOffset());
}
void QGraphicsDropShadowEffect_DestroyQGraphicsDropShadowEffect(void* ptr)
{
static_cast<QGraphicsDropShadowEffect*>(ptr)->~QGraphicsDropShadowEffect();
}
void QGraphicsDropShadowEffect_SetEnabled(void* ptr, int enable)
{
QMetaObject::invokeMethod(static_cast<QGraphicsDropShadowEffect*>(ptr), "setEnabled", Q_ARG(bool, enable != 0));
}
void QGraphicsDropShadowEffect_SetEnabledDefault(void* ptr, int enable)
{
static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::setEnabled(enable != 0);
}
void QGraphicsDropShadowEffect_SourceChanged(void* ptr, int flags)
{
static_cast<QGraphicsDropShadowEffect*>(ptr)->sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}
void QGraphicsDropShadowEffect_SourceChangedDefault(void* ptr, int 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));
}
int QGraphicsDropShadowEffect_Event(void* ptr, void* e)
{
return static_cast<QGraphicsDropShadowEffect*>(ptr)->event(static_cast<QEvent*>(e));
}
int QGraphicsDropShadowEffect_EventDefault(void* ptr, void* e)
{
return static_cast<QGraphicsDropShadowEffect*>(ptr)->QGraphicsDropShadowEffect::event(static_cast<QEvent*>(e));
}
int QGraphicsDropShadowEffect_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsDropShadowEffect*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), enable); };
QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsEffect_BoundingRectFor(const_cast<MyQGraphicsEffect*>(this), this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height()))); };
void draw(QPainter * painter) { callbackQGraphicsEffect_Draw(this, this->objectName().toUtf8().data(), painter); };
void Signal_EnabledChanged(bool enabled) { callbackQGraphicsEffect_EnabledChanged(this, this->objectName().toUtf8().data(), enabled); };
void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsEffect_SourceChanged(this, this->objectName().toUtf8().data(), flags); };
void update() { callbackQGraphicsEffect_Update(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsEffect_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsEffect_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsEffect_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsEffect_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsEffect_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsEffect_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQGraphicsEffect_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsEffect_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsEffect_MetaObject(const_cast<MyQGraphicsEffect*>(this), this->objectName().toUtf8().data())); };
};
int QGraphicsEffect_IsEnabled(void* ptr)
{
return static_cast<QGraphicsEffect*>(ptr)->isEnabled();
}
void QGraphicsEffect_SetEnabled(void* ptr, int 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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->boundingRect()).height());
}
void* QGraphicsEffect_BoundingRectFor(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).height());
}
void* QGraphicsEffect_BoundingRectForDefault(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::boundingRectFor(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::boundingRectFor(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::boundingRectFor(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::boundingRectFor(*static_cast<QRectF*>(rect))).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, int enabled)
{
static_cast<QGraphicsEffect*>(ptr)->enabledChanged(enabled != 0);
}
void* QGraphicsEffect_SourceBoundingRect(void* ptr, int system)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->sourceBoundingRect(static_cast<Qt::CoordinateSystem>(system))).x(), static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->sourceBoundingRect(static_cast<Qt::CoordinateSystem>(system))).y(), static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->sourceBoundingRect(static_cast<Qt::CoordinateSystem>(system))).width(), static_cast<QRectF>(static_cast<QGraphicsEffect*>(ptr)->sourceBoundingRect(static_cast<Qt::CoordinateSystem>(system))).height());
}
void QGraphicsEffect_SourceChanged(void* ptr, int flags)
{
static_cast<QGraphicsEffect*>(ptr)->sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}
void QGraphicsEffect_SourceChangedDefault(void* ptr, int flags)
{
static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}
int QGraphicsEffect_SourceIsPixmap(void* ptr)
{
return static_cast<QGraphicsEffect*>(ptr)->sourceIsPixmap();
}
void* QGraphicsEffect_SourcePixmap(void* ptr, int system, void* offset, int 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_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));
}
int QGraphicsEffect_Event(void* ptr, void* e)
{
return static_cast<QGraphicsEffect*>(ptr)->event(static_cast<QEvent*>(e));
}
int QGraphicsEffect_EventDefault(void* ptr, void* e)
{
return static_cast<QGraphicsEffect*>(ptr)->QGraphicsEffect::event(static_cast<QEvent*>(e));
}
int QGraphicsEffect_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsEffect*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
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), this->objectNameAbs().toUtf8().data())); };
bool contains(const QPointF & point) const { return callbackQGraphicsEllipseItem_Contains(const_cast<MyQGraphicsEllipseItem*>(this), this->objectNameAbs().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsEllipseItem_IsObscuredBy(const_cast<MyQGraphicsEllipseItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsEllipseItem_OpaqueArea(const_cast<MyQGraphicsEllipseItem*>(this), this->objectNameAbs().toUtf8().data())); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsEllipseItem_Paint(this, this->objectNameAbs().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsEllipseItem_Shape(const_cast<MyQGraphicsEllipseItem*>(this), this->objectNameAbs().toUtf8().data())); };
int type() const { return callbackQGraphicsEllipseItem_Type(const_cast<MyQGraphicsEllipseItem*>(this), this->objectNameAbs().toUtf8().data()); };
void advance(int phase) { callbackQGraphicsEllipseItem_Advance(this, this->objectNameAbs().toUtf8().data(), phase); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsEllipseItem_CollidesWithItem(const_cast<MyQGraphicsEllipseItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsEllipseItem_CollidesWithPath(const_cast<MyQGraphicsEllipseItem*>(this), this->objectNameAbs().toUtf8().data(), new QPainterPath(path), mode) != 0; };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsEllipseItem_ContextMenuEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsEllipseItem_DragEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsEllipseItem_DragLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsEllipseItem_DragMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsEllipseItem_DropEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsEllipseItem_FocusInEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsEllipseItem_FocusOutEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsEllipseItem_HoverEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsEllipseItem_HoverLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsEllipseItem_HoverMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsEllipseItem_InputMethodEvent(this, this->objectNameAbs().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsEllipseItem_InputMethodQuery(const_cast<MyQGraphicsEllipseItem*>(this), this->objectNameAbs().toUtf8().data(), query)); };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsEllipseItem_ItemChange(this, this->objectNameAbs().toUtf8().data(), change, new QVariant(value))); };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsEllipseItem_KeyPressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsEllipseItem_KeyReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsEllipseItem_MouseDoubleClickEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsEllipseItem_MouseMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsEllipseItem_MousePressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsEllipseItem_MouseReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
bool sceneEvent(QEvent * event) { return callbackQGraphicsEllipseItem_SceneEvent(this, this->objectNameAbs().toUtf8().data(), event) != 0; };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsEllipseItem_SceneEventFilter(this, this->objectNameAbs().toUtf8().data(), watched, event) != 0; };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsEllipseItem_WheelEvent(this, this->objectNameAbs().toUtf8().data(), event); };
};
void* QGraphicsEllipseItem_NewQGraphicsEllipseItem3(double x, double y, double width, double height, void* parent)
{
return new MyQGraphicsEllipseItem(static_cast<double>(x), static_cast<double>(y), static_cast<double>(width), static_cast<double>(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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsEllipseItem*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsEllipseItem*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsEllipseItem*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsEllipseItem*>(ptr)->boundingRect()).height());
}
void* QGraphicsEllipseItem_BoundingRectDefault(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::boundingRect()).height());
}
int QGraphicsEllipseItem_Contains(void* ptr, void* point)
{
return static_cast<QGraphicsEllipseItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int QGraphicsEllipseItem_ContainsDefault(void* ptr, void* point)
{
return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::contains(*static_cast<QPointF*>(point));
}
int QGraphicsEllipseItem_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QGraphicsEllipseItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int 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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsEllipseItem*>(ptr)->rect()).x(), static_cast<QRectF>(static_cast<QGraphicsEllipseItem*>(ptr)->rect()).y(), static_cast<QRectF>(static_cast<QGraphicsEllipseItem*>(ptr)->rect()).width(), static_cast<QRectF>(static_cast<QGraphicsEllipseItem*>(ptr)->rect()).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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(width), static_cast<double>(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();
}
char* QGraphicsEllipseItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsEllipseItem*>(static_cast<QGraphicsEllipseItem*>(ptr))) {
return static_cast<MyQGraphicsEllipseItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsEllipseItem_BASE").toUtf8().data();
}
void QGraphicsEllipseItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsEllipseItem*>(static_cast<QGraphicsEllipseItem*>(ptr))) {
static_cast<MyQGraphicsEllipseItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
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);
}
int QGraphicsEllipseItem_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsEllipseItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsEllipseItem_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsEllipseItem_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsEllipseItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsEllipseItem_CollidesWithPathDefault(void* ptr, void* path, int 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, int query)
{
return new QVariant(static_cast<QGraphicsEllipseItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsEllipseItem_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsEllipseItem_ItemChange(void* ptr, int 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, int 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));
}
int QGraphicsEllipseItem_SceneEvent(void* ptr, void* event)
{
return static_cast<QGraphicsEllipseItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsEllipseItem_SceneEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsEllipseItem*>(ptr)->QGraphicsEllipseItem::sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsEllipseItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsEllipseItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQGraphicsGridLayout(QGraphicsLayoutItem *parent) : QGraphicsGridLayout(parent) {};
int count() const { return callbackQGraphicsGridLayout_Count(const_cast<MyQGraphicsGridLayout*>(this), this->objectNameAbs().toUtf8().data()); };
void invalidate() { callbackQGraphicsGridLayout_Invalidate(this, this->objectNameAbs().toUtf8().data()); };
QGraphicsLayoutItem * itemAt(int index) const { return static_cast<QGraphicsLayoutItem*>(callbackQGraphicsGridLayout_ItemAt2(const_cast<MyQGraphicsGridLayout*>(this), this->objectNameAbs().toUtf8().data(), index)); };
void removeAt(int index) { callbackQGraphicsGridLayout_RemoveAt(this, this->objectNameAbs().toUtf8().data(), index); };
void setGeometry(const QRectF & rect) { callbackQGraphicsGridLayout_SetGeometry(this, this->objectNameAbs().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height())); };
QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsGridLayout_SizeHint(const_cast<MyQGraphicsGridLayout*>(this), this->objectNameAbs().toUtf8().data(), which, new QSizeF(static_cast<QSizeF>(constraint).width(), static_cast<QSizeF>(constraint).height()))); };
void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsGridLayout_GetContentsMargins(const_cast<MyQGraphicsGridLayout*>(this), this->objectNameAbs().toUtf8().data(), *static_cast<double*>(left), *static_cast<double*>(top), *static_cast<double*>(right), *static_cast<double*>(bottom)); };
void updateGeometry() { callbackQGraphicsGridLayout_UpdateGeometry(this, this->objectNameAbs().toUtf8().data()); };
void widgetEvent(QEvent * e) { callbackQGraphicsGridLayout_WidgetEvent(this, this->objectNameAbs().toUtf8().data(), e); };
};
void* QGraphicsGridLayout_NewQGraphicsGridLayout(void* parent)
{
return new MyQGraphicsGridLayout(static_cast<QGraphicsLayoutItem*>(parent));
}
void QGraphicsGridLayout_AddItem2(void* ptr, void* item, int row, int column, int 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, int alignment)
{
static_cast<QGraphicsGridLayout*>(ptr)->addItem(static_cast<QGraphicsLayoutItem*>(item), row, column, rowSpan, columnSpan, static_cast<Qt::AlignmentFlag>(alignment));
}
int QGraphicsGridLayout_Alignment(void* ptr, void* item)
{
return static_cast<QGraphicsGridLayout*>(ptr)->alignment(static_cast<QGraphicsLayoutItem*>(item));
}
int 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<double>(static_cast<QGraphicsGridLayout*>(ptr)->columnMaximumWidth(column));
}
double QGraphicsGridLayout_ColumnMinimumWidth(void* ptr, int column)
{
return static_cast<double>(static_cast<QGraphicsGridLayout*>(ptr)->columnMinimumWidth(column));
}
double QGraphicsGridLayout_ColumnPreferredWidth(void* ptr, int column)
{
return static_cast<double>(static_cast<QGraphicsGridLayout*>(ptr)->columnPreferredWidth(column));
}
double QGraphicsGridLayout_ColumnSpacing(void* ptr, int column)
{
return static_cast<double>(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<double>(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));
}
int 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<double>(static_cast<QGraphicsGridLayout*>(ptr)->rowMaximumHeight(row));
}
double QGraphicsGridLayout_RowMinimumHeight(void* ptr, int row)
{
return static_cast<double>(static_cast<QGraphicsGridLayout*>(ptr)->rowMinimumHeight(row));
}
double QGraphicsGridLayout_RowPreferredHeight(void* ptr, int row)
{
return static_cast<double>(static_cast<QGraphicsGridLayout*>(ptr)->rowPreferredHeight(row));
}
double QGraphicsGridLayout_RowSpacing(void* ptr, int row)
{
return static_cast<double>(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, int alignment)
{
static_cast<QGraphicsGridLayout*>(ptr)->setAlignment(static_cast<QGraphicsLayoutItem*>(item), static_cast<Qt::AlignmentFlag>(alignment));
}
void QGraphicsGridLayout_SetColumnAlignment(void* ptr, int column, int 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, static_cast<double>(width));
}
void QGraphicsGridLayout_SetColumnMaximumWidth(void* ptr, int column, double width)
{
static_cast<QGraphicsGridLayout*>(ptr)->setColumnMaximumWidth(column, static_cast<double>(width));
}
void QGraphicsGridLayout_SetColumnMinimumWidth(void* ptr, int column, double width)
{
static_cast<QGraphicsGridLayout*>(ptr)->setColumnMinimumWidth(column, static_cast<double>(width));
}
void QGraphicsGridLayout_SetColumnPreferredWidth(void* ptr, int column, double width)
{
static_cast<QGraphicsGridLayout*>(ptr)->setColumnPreferredWidth(column, static_cast<double>(width));
}
void QGraphicsGridLayout_SetColumnSpacing(void* ptr, int column, double spacing)
{
static_cast<QGraphicsGridLayout*>(ptr)->setColumnSpacing(column, static_cast<double>(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(static_cast<double>(spacing));
}
void QGraphicsGridLayout_SetRowAlignment(void* ptr, int row, int 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, static_cast<double>(height));
}
void QGraphicsGridLayout_SetRowMaximumHeight(void* ptr, int row, double height)
{
static_cast<QGraphicsGridLayout*>(ptr)->setRowMaximumHeight(row, static_cast<double>(height));
}
void QGraphicsGridLayout_SetRowMinimumHeight(void* ptr, int row, double height)
{
static_cast<QGraphicsGridLayout*>(ptr)->setRowMinimumHeight(row, static_cast<double>(height));
}
void QGraphicsGridLayout_SetRowPreferredHeight(void* ptr, int row, double height)
{
static_cast<QGraphicsGridLayout*>(ptr)->setRowPreferredHeight(row, static_cast<double>(height));
}
void QGraphicsGridLayout_SetRowSpacing(void* ptr, int row, double spacing)
{
static_cast<QGraphicsGridLayout*>(ptr)->setRowSpacing(row, static_cast<double>(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(static_cast<double>(spacing));
}
void QGraphicsGridLayout_SetVerticalSpacing(void* ptr, double spacing)
{
static_cast<QGraphicsGridLayout*>(ptr)->setVerticalSpacing(static_cast<double>(spacing));
}
void* QGraphicsGridLayout_SizeHint(void* ptr, int which, void* constraint)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsGridLayout*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).width(), static_cast<QSizeF>(static_cast<QGraphicsGridLayout*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).height());
}
void* QGraphicsGridLayout_SizeHintDefault(void* ptr, int which, void* constraint)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).width(), static_cast<QSizeF>(static_cast<QGraphicsGridLayout*>(ptr)->QGraphicsGridLayout::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).height());
}
double QGraphicsGridLayout_VerticalSpacing(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsGridLayout*>(ptr)->verticalSpacing());
}
void QGraphicsGridLayout_DestroyQGraphicsGridLayout(void* ptr)
{
static_cast<QGraphicsGridLayout*>(ptr)->~QGraphicsGridLayout();
}
char* QGraphicsGridLayout_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsGridLayout*>(static_cast<QGraphicsGridLayout*>(ptr))) {
return static_cast<MyQGraphicsGridLayout*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsGridLayout_BASE").toUtf8().data();
}
void QGraphicsGridLayout_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsGridLayout*>(static_cast<QGraphicsGridLayout*>(ptr))) {
static_cast<MyQGraphicsGridLayout*>(ptr)->setObjectNameAbs(QString(name));
}
}
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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQGraphicsItem(QGraphicsItem *parent) : QGraphicsItem(parent) {};
void advance(int phase) { callbackQGraphicsItem_Advance(this, this->objectNameAbs().toUtf8().data(), phase); };
QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsItem_BoundingRect(const_cast<MyQGraphicsItem*>(this), this->objectNameAbs().toUtf8().data())); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithItem(const_cast<MyQGraphicsItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItem_CollidesWithPath(const_cast<MyQGraphicsItem*>(this), this->objectNameAbs().toUtf8().data(), new QPainterPath(path), mode) != 0; };
bool contains(const QPointF & point) const { return callbackQGraphicsItem_Contains(const_cast<MyQGraphicsItem*>(this), this->objectNameAbs().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItem_ContextMenuEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DragMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItem_DropEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusInEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItem_FocusOutEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItem_HoverMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItem_InputMethodEvent(this, this->objectNameAbs().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItem_InputMethodQuery(const_cast<MyQGraphicsItem*>(this), this->objectNameAbs().toUtf8().data(), query)); };
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItem_IsObscuredBy(const_cast<MyQGraphicsItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItem_ItemChange(this, this->objectNameAbs().toUtf8().data(), change, new QVariant(value))); };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyPressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItem_KeyReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseDoubleClickEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MousePressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItem_MouseReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_OpaqueArea(const_cast<MyQGraphicsItem*>(this), this->objectNameAbs().toUtf8().data())); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsItem_Paint(this, this->objectNameAbs().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
bool sceneEvent(QEvent * event) { return callbackQGraphicsItem_SceneEvent(this, this->objectNameAbs().toUtf8().data(), event) != 0; };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItem_SceneEventFilter(this, this->objectNameAbs().toUtf8().data(), watched, event) != 0; };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItem_Shape(const_cast<MyQGraphicsItem*>(this), this->objectNameAbs().toUtf8().data())); };
int type() const { return callbackQGraphicsItem_Type(const_cast<MyQGraphicsItem*>(this), this->objectNameAbs().toUtf8().data()); };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItem_WheelEvent(this, this->objectNameAbs().toUtf8().data(), event); };
};
void* QGraphicsItem_NewQGraphicsItem(void* parent)
{
return new MyQGraphicsItem(static_cast<QGraphicsItem*>(parent));
}
int QGraphicsItem_AcceptedMouseButtons(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->acceptedMouseButtons();
}
int QGraphicsItem_AcceptDrops(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->acceptDrops();
}
int QGraphicsItem_AcceptHoverEvents(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->acceptHoverEvents();
}
int 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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->boundingRect()).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<double>(static_cast<QGraphicsItem*>(ptr)->boundingRegionGranularity());
}
int QGraphicsItem_CacheMode(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->cacheMode();
}
void* QGraphicsItem_ChildrenBoundingRect(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->childrenBoundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->childrenBoundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->childrenBoundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->childrenBoundingRect()).height());
}
void QGraphicsItem_ClearFocus(void* ptr)
{
static_cast<QGraphicsItem*>(ptr)->clearFocus();
}
void* QGraphicsItem_ClipPath(void* ptr)
{
return new QPainterPath(static_cast<QGraphicsItem*>(ptr)->clipPath());
}
int QGraphicsItem_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsItem_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsItem_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsItem_CollidesWithPathDefault(void* ptr, void* path, int 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));
}
int QGraphicsItem_Contains(void* ptr, void* point)
{
return static_cast<QGraphicsItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int 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_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<double>(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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(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();
}
int QGraphicsItem_FiltersChildEvents(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->filtersChildEvents();
}
int 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();
}
int QGraphicsItem_HasCursor(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->hasCursor();
}
int 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));
}
int QGraphicsItem_InputMethodHints(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->inputMethodHints();
}
void* QGraphicsItem_InputMethodQuery(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsItem_InputMethodQueryDefault(void* ptr, int 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));
}
int QGraphicsItem_IsActive(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->isActive();
}
int QGraphicsItem_IsAncestorOf(void* ptr, void* child)
{
return static_cast<QGraphicsItem*>(ptr)->isAncestorOf(static_cast<QGraphicsItem*>(child));
}
int QGraphicsItem_IsClipped(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->isClipped();
}
int QGraphicsItem_IsEnabled(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->isEnabled();
}
int QGraphicsItem_IsObscured(void* ptr, void* rect)
{
return static_cast<QGraphicsItem*>(ptr)->isObscured(*static_cast<QRectF*>(rect));
}
int QGraphicsItem_IsObscured2(void* ptr, double x, double y, double w, double h)
{
return static_cast<QGraphicsItem*>(ptr)->isObscured(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h));
}
int QGraphicsItem_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QGraphicsItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int QGraphicsItem_IsObscuredByDefault(void* ptr, void* item)
{
return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int QGraphicsItem_IsPanel(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->isPanel();
}
int QGraphicsItem_IsSelected(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->isSelected();
}
int QGraphicsItem_IsUnderMouse(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->isUnderMouse();
}
int QGraphicsItem_IsVisible(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->isVisible();
}
int QGraphicsItem_IsVisibleTo(void* ptr, void* parent)
{
return static_cast<QGraphicsItem*>(ptr)->isVisibleTo(static_cast<QGraphicsItem*>(parent));
}
int QGraphicsItem_IsWidget(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->isWidget();
}
int QGraphicsItem_IsWindow(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->isWindow();
}
void* QGraphicsItem_ItemChange(void* ptr, int 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, int change, void* value)
{
return new QVariant(static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}
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 new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPointF*>(point))).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QPointF*>(point))).y());
}
void* QGraphicsItem_MapFromItem5(void* ptr, void* item, double x, double y)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), static_cast<double>(x), static_cast<double>(y))).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapFromItem(static_cast<QGraphicsItem*>(item), static_cast<double>(x), static_cast<double>(y))).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), static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(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 new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapFromParent(*static_cast<QPointF*>(point))).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapFromParent(*static_cast<QPointF*>(point))).y());
}
void* QGraphicsItem_MapFromParent5(void* ptr, double x, double y)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapFromParent(static_cast<double>(x), static_cast<double>(y))).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapFromParent(static_cast<double>(x), static_cast<double>(y))).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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(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 new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapFromScene(*static_cast<QPointF*>(point))).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapFromScene(*static_cast<QPointF*>(point))).y());
}
void* QGraphicsItem_MapFromScene5(void* ptr, double x, double y)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapFromScene(static_cast<double>(x), static_cast<double>(y))).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapFromScene(static_cast<double>(x), static_cast<double>(y))).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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h)));
}
void* QGraphicsItem_MapRectFromItem(void* ptr, void* item, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect))).height());
}
void* QGraphicsItem_MapRectFromItem2(void* ptr, void* item, double x, double y, double w, double h)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromItem(static_cast<QGraphicsItem*>(item), static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).height());
}
void* QGraphicsItem_MapRectFromParent(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromParent(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromParent(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromParent(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromParent(*static_cast<QRectF*>(rect))).height());
}
void* QGraphicsItem_MapRectFromParent2(void* ptr, double x, double y, double w, double h)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromParent(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromParent(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromParent(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromParent(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).height());
}
void* QGraphicsItem_MapRectFromScene(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromScene(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromScene(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromScene(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromScene(*static_cast<QRectF*>(rect))).height());
}
void* QGraphicsItem_MapRectFromScene2(void* ptr, double x, double y, double w, double h)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromScene(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromScene(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromScene(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectFromScene(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).height());
}
void* QGraphicsItem_MapRectToItem(void* ptr, void* item, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), *static_cast<QRectF*>(rect))).height());
}
void* QGraphicsItem_MapRectToItem2(void* ptr, void* item, double x, double y, double w, double h)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToItem(static_cast<QGraphicsItem*>(item), static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).height());
}
void* QGraphicsItem_MapRectToParent(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToParent(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToParent(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToParent(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToParent(*static_cast<QRectF*>(rect))).height());
}
void* QGraphicsItem_MapRectToParent2(void* ptr, double x, double y, double w, double h)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToParent(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToParent(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToParent(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToParent(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).height());
}
void* QGraphicsItem_MapRectToScene(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToScene(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToScene(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToScene(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToScene(*static_cast<QRectF*>(rect))).height());
}
void* QGraphicsItem_MapRectToScene2(void* ptr, double x, double y, double w, double h)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToScene(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToScene(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToScene(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->mapRectToScene(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h))).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 new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPointF*>(point))).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), *static_cast<QPointF*>(point))).y());
}
void* QGraphicsItem_MapToItem5(void* ptr, void* item, double x, double y)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), static_cast<double>(x), static_cast<double>(y))).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapToItem(static_cast<QGraphicsItem*>(item), static_cast<double>(x), static_cast<double>(y))).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), static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(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 new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapToParent(*static_cast<QPointF*>(point))).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapToParent(*static_cast<QPointF*>(point))).y());
}
void* QGraphicsItem_MapToParent5(void* ptr, double x, double y)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapToParent(static_cast<double>(x), static_cast<double>(y))).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapToParent(static_cast<double>(x), static_cast<double>(y))).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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(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 new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapToScene(*static_cast<QPointF*>(point))).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapToScene(*static_cast<QPointF*>(point))).y());
}
void* QGraphicsItem_MapToScene5(void* ptr, double x, double y)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapToScene(static_cast<double>(x), static_cast<double>(y))).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->mapToScene(static_cast<double>(x), static_cast<double>(y))).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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(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(static_cast<double>(dx), static_cast<double>(dy));
}
double QGraphicsItem_Opacity(void* ptr)
{
return static_cast<double>(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();
}
int 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 new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->pos()).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->pos()).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<double>(static_cast<QGraphicsItem*>(ptr)->rotation());
}
double QGraphicsItem_Scale(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsItem*>(ptr)->scale());
}
void* QGraphicsItem_Scene(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->scene();
}
void* QGraphicsItem_SceneBoundingRect(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->sceneBoundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->sceneBoundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->sceneBoundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsItem*>(ptr)->sceneBoundingRect()).height());
}
int QGraphicsItem_SceneEvent(void* ptr, void* event)
{
return static_cast<QGraphicsItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsItem_SceneEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsItem*>(ptr)->QGraphicsItem::sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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 new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->scenePos()).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->scenePos()).y());
}
void QGraphicsItem_Scroll(void* ptr, double dx, double dy, void* rect)
{
static_cast<QGraphicsItem*>(ptr)->scroll(static_cast<double>(dx), static_cast<double>(dy), *static_cast<QRectF*>(rect));
}
void QGraphicsItem_SetAcceptDrops(void* ptr, int on)
{
static_cast<QGraphicsItem*>(ptr)->setAcceptDrops(on != 0);
}
void QGraphicsItem_SetAcceptHoverEvents(void* ptr, int enabled)
{
static_cast<QGraphicsItem*>(ptr)->setAcceptHoverEvents(enabled != 0);
}
void QGraphicsItem_SetAcceptTouchEvents(void* ptr, int enabled)
{
static_cast<QGraphicsItem*>(ptr)->setAcceptTouchEvents(enabled != 0);
}
void QGraphicsItem_SetAcceptedMouseButtons(void* ptr, int buttons)
{
static_cast<QGraphicsItem*>(ptr)->setAcceptedMouseButtons(static_cast<Qt::MouseButton>(buttons));
}
void QGraphicsItem_SetActive(void* ptr, int active)
{
static_cast<QGraphicsItem*>(ptr)->setActive(active != 0);
}
void QGraphicsItem_SetBoundingRegionGranularity(void* ptr, double granularity)
{
static_cast<QGraphicsItem*>(ptr)->setBoundingRegionGranularity(static_cast<double>(granularity));
}
void QGraphicsItem_SetCacheMode(void* ptr, int 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, int enabled)
{
static_cast<QGraphicsItem*>(ptr)->setEnabled(enabled != 0);
}
void QGraphicsItem_SetFiltersChildEvents(void* ptr, int enabled)
{
static_cast<QGraphicsItem*>(ptr)->setFiltersChildEvents(enabled != 0);
}
void QGraphicsItem_SetFlag(void* ptr, int flag, int enabled)
{
static_cast<QGraphicsItem*>(ptr)->setFlag(static_cast<QGraphicsItem::GraphicsItemFlag>(flag), enabled != 0);
}
void QGraphicsItem_SetFlags(void* ptr, int flags)
{
static_cast<QGraphicsItem*>(ptr)->setFlags(static_cast<QGraphicsItem::GraphicsItemFlag>(flags));
}
void QGraphicsItem_SetFocus(void* ptr, int 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, int hints)
{
static_cast<QGraphicsItem*>(ptr)->setInputMethodHints(static_cast<Qt::InputMethodHint>(hints));
}
void QGraphicsItem_SetOpacity(void* ptr, double opacity)
{
static_cast<QGraphicsItem*>(ptr)->setOpacity(static_cast<double>(opacity));
}
void QGraphicsItem_SetPanelModality(void* ptr, int 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(static_cast<double>(x), static_cast<double>(y));
}
void QGraphicsItem_SetRotation(void* ptr, double angle)
{
static_cast<QGraphicsItem*>(ptr)->setRotation(static_cast<double>(angle));
}
void QGraphicsItem_SetScale(void* ptr, double factor)
{
static_cast<QGraphicsItem*>(ptr)->setScale(static_cast<double>(factor));
}
void QGraphicsItem_SetSelected(void* ptr, int 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, int 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(static_cast<double>(x), static_cast<double>(y));
}
void QGraphicsItem_SetVisible(void* ptr, int visible)
{
static_cast<QGraphicsItem*>(ptr)->setVisible(visible != 0);
}
void QGraphicsItem_SetX(void* ptr, double x)
{
static_cast<QGraphicsItem*>(ptr)->setX(static_cast<double>(x));
}
void QGraphicsItem_SetY(void* ptr, double y)
{
static_cast<QGraphicsItem*>(ptr)->setY(static_cast<double>(y));
}
void QGraphicsItem_SetZValue(void* ptr, double z)
{
static_cast<QGraphicsItem*>(ptr)->setZValue(static_cast<double>(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 static_cast<QGraphicsItem*>(ptr)->toolTip().toUtf8().data();
}
void* QGraphicsItem_TopLevelItem(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->topLevelItem();
}
void* QGraphicsItem_TopLevelWidget(void* ptr)
{
return static_cast<QGraphicsItem*>(ptr)->topLevelWidget();
}
void* QGraphicsItem_TransformOriginPoint(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->transformOriginPoint()).x(), static_cast<QPointF>(static_cast<QGraphicsItem*>(ptr)->transformOriginPoint()).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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(width), static_cast<double>(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<double>(static_cast<QGraphicsItem*>(ptr)->x());
}
double QGraphicsItem_Y(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsItem*>(ptr)->y());
}
double QGraphicsItem_ZValue(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsItem*>(ptr)->zValue());
}
void QGraphicsItem_DestroyQGraphicsItem(void* ptr)
{
static_cast<QGraphicsItem*>(ptr)->~QGraphicsItem();
}
char* QGraphicsItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsItem*>(static_cast<QGraphicsItem*>(ptr))) {
return static_cast<MyQGraphicsItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsItem_BASE").toUtf8().data();
}
void QGraphicsItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsItem*>(static_cast<QGraphicsItem*>(ptr))) {
static_cast<MyQGraphicsItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
class MyQGraphicsItemGroup: public QGraphicsItemGroup
{
public:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQGraphicsItemGroup(QGraphicsItem *parent) : QGraphicsItemGroup(parent) {};
QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsItemGroup_BoundingRect(const_cast<MyQGraphicsItemGroup*>(this), this->objectNameAbs().toUtf8().data())); };
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsItemGroup_IsObscuredBy(const_cast<MyQGraphicsItemGroup*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsItemGroup_OpaqueArea(const_cast<MyQGraphicsItemGroup*>(this), this->objectNameAbs().toUtf8().data())); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsItemGroup_Paint(this, this->objectNameAbs().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
int type() const { return callbackQGraphicsItemGroup_Type(const_cast<MyQGraphicsItemGroup*>(this), this->objectNameAbs().toUtf8().data()); };
void advance(int phase) { callbackQGraphicsItemGroup_Advance(this, this->objectNameAbs().toUtf8().data(), phase); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItemGroup_CollidesWithItem(const_cast<MyQGraphicsItemGroup*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsItemGroup_CollidesWithPath(const_cast<MyQGraphicsItemGroup*>(this), this->objectNameAbs().toUtf8().data(), new QPainterPath(path), mode) != 0; };
bool contains(const QPointF & point) const { return callbackQGraphicsItemGroup_Contains(const_cast<MyQGraphicsItemGroup*>(this), this->objectNameAbs().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsItemGroup_ContextMenuEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItemGroup_DragEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItemGroup_DragLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItemGroup_DragMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsItemGroup_DropEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsItemGroup_FocusInEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsItemGroup_FocusOutEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItemGroup_HoverEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItemGroup_HoverLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsItemGroup_HoverMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsItemGroup_InputMethodEvent(this, this->objectNameAbs().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsItemGroup_InputMethodQuery(const_cast<MyQGraphicsItemGroup*>(this), this->objectNameAbs().toUtf8().data(), query)); };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsItemGroup_ItemChange(this, this->objectNameAbs().toUtf8().data(), change, new QVariant(value))); };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsItemGroup_KeyPressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsItemGroup_KeyReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItemGroup_MouseDoubleClickEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItemGroup_MouseMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItemGroup_MousePressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsItemGroup_MouseReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
bool sceneEvent(QEvent * event) { return callbackQGraphicsItemGroup_SceneEvent(this, this->objectNameAbs().toUtf8().data(), event) != 0; };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsItemGroup_SceneEventFilter(this, this->objectNameAbs().toUtf8().data(), watched, event) != 0; };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsItemGroup_Shape(const_cast<MyQGraphicsItemGroup*>(this), this->objectNameAbs().toUtf8().data())); };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsItemGroup_WheelEvent(this, this->objectNameAbs().toUtf8().data(), 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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsItemGroup*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsItemGroup*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsItemGroup*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsItemGroup*>(ptr)->boundingRect()).height());
}
void* QGraphicsItemGroup_BoundingRectDefault(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::boundingRect()).height());
}
int QGraphicsItemGroup_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QGraphicsItemGroup*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int 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();
}
char* QGraphicsItemGroup_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsItemGroup*>(static_cast<QGraphicsItemGroup*>(ptr))) {
return static_cast<MyQGraphicsItemGroup*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsItemGroup_BASE").toUtf8().data();
}
void QGraphicsItemGroup_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsItemGroup*>(static_cast<QGraphicsItemGroup*>(ptr))) {
static_cast<MyQGraphicsItemGroup*>(ptr)->setObjectNameAbs(QString(name));
}
}
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);
}
int QGraphicsItemGroup_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsItemGroup*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsItemGroup_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsItemGroup_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsItemGroup*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsItemGroup_CollidesWithPathDefault(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsItemGroup_Contains(void* ptr, void* point)
{
return static_cast<QGraphicsItemGroup*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int 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, int query)
{
return new QVariant(static_cast<QGraphicsItemGroup*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsItemGroup_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsItemGroup_ItemChange(void* ptr, int 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, int 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));
}
int QGraphicsItemGroup_SceneEvent(void* ptr, void* event)
{
return static_cast<QGraphicsItemGroup*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsItemGroup_SceneEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsItemGroup*>(ptr)->QGraphicsItemGroup::sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsItemGroup_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsItemGroup*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQGraphicsLayout(QGraphicsLayoutItem *parent) : QGraphicsLayout(parent) {};
int count() const { return callbackQGraphicsLayout_Count(const_cast<MyQGraphicsLayout*>(this), this->objectNameAbs().toUtf8().data()); };
void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsLayout_GetContentsMargins(const_cast<MyQGraphicsLayout*>(this), this->objectNameAbs().toUtf8().data(), *static_cast<double*>(left), *static_cast<double*>(top), *static_cast<double*>(right), *static_cast<double*>(bottom)); };
void invalidate() { callbackQGraphicsLayout_Invalidate(this, this->objectNameAbs().toUtf8().data()); };
QGraphicsLayoutItem * itemAt(int i) const { return static_cast<QGraphicsLayoutItem*>(callbackQGraphicsLayout_ItemAt(const_cast<MyQGraphicsLayout*>(this), this->objectNameAbs().toUtf8().data(), i)); };
void removeAt(int index) { callbackQGraphicsLayout_RemoveAt(this, this->objectNameAbs().toUtf8().data(), index); };
void updateGeometry() { callbackQGraphicsLayout_UpdateGeometry(this, this->objectNameAbs().toUtf8().data()); };
void widgetEvent(QEvent * e) { callbackQGraphicsLayout_WidgetEvent(this, this->objectNameAbs().toUtf8().data(), e); };
void setGeometry(const QRectF & rect) { callbackQGraphicsLayout_SetGeometry(this, this->objectNameAbs().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height())); };
QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsLayout_SizeHint(const_cast<MyQGraphicsLayout*>(this), this->objectNameAbs().toUtf8().data(), which, new QSizeF(static_cast<QSizeF>(constraint).width(), static_cast<QSizeF>(constraint).height()))); };
};
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_Invalidate(void* ptr)
{
static_cast<QGraphicsLayout*>(ptr)->invalidate();
}
void QGraphicsLayout_InvalidateDefault(void* ptr)
{
static_cast<QGraphicsLayout*>(ptr)->QGraphicsLayout::invalidate();
}
int 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(static_cast<double>(left), static_cast<double>(top), static_cast<double>(right), static_cast<double>(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();
}
char* QGraphicsLayout_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsLayout*>(static_cast<QGraphicsLayout*>(ptr))) {
return static_cast<MyQGraphicsLayout*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsLayout_BASE").toUtf8().data();
}
void QGraphicsLayout_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsLayout*>(static_cast<QGraphicsLayout*>(ptr))) {
static_cast<MyQGraphicsLayout*>(ptr)->setObjectNameAbs(QString(name));
}
}
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, int which, void* constraint)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsLayout*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).width(), static_cast<QSizeF>(static_cast<QGraphicsLayout*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).height());
}
class MyQGraphicsLayoutItem: public QGraphicsLayoutItem
{
public:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQGraphicsLayoutItem(QGraphicsLayoutItem *parent, bool isLayout) : QGraphicsLayoutItem(parent, isLayout) {};
void setGeometry(const QRectF & rect) { callbackQGraphicsLayoutItem_SetGeometry(this, this->objectNameAbs().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height())); };
void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsLayoutItem_GetContentsMargins(const_cast<MyQGraphicsLayoutItem*>(this), this->objectNameAbs().toUtf8().data(), *static_cast<double*>(left), *static_cast<double*>(top), *static_cast<double*>(right), *static_cast<double*>(bottom)); };
QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsLayoutItem_SizeHint(const_cast<MyQGraphicsLayoutItem*>(this), this->objectNameAbs().toUtf8().data(), which, new QSizeF(static_cast<QSizeF>(constraint).width(), static_cast<QSizeF>(constraint).height()))); };
void updateGeometry() { callbackQGraphicsLayoutItem_UpdateGeometry(this, this->objectNameAbs().toUtf8().data()); };
};
void* QGraphicsLayoutItem_Geometry(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsLayoutItem*>(ptr)->geometry()).x(), static_cast<QRectF>(static_cast<QGraphicsLayoutItem*>(ptr)->geometry()).y(), static_cast<QRectF>(static_cast<QGraphicsLayoutItem*>(ptr)->geometry()).width(), static_cast<QRectF>(static_cast<QGraphicsLayoutItem*>(ptr)->geometry()).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, int isLayout)
{
return new MyQGraphicsLayoutItem(static_cast<QGraphicsLayoutItem*>(parent), isLayout != 0);
}
void* QGraphicsLayoutItem_ContentsRect(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsLayoutItem*>(ptr)->contentsRect()).x(), static_cast<QRectF>(static_cast<QGraphicsLayoutItem*>(ptr)->contentsRect()).y(), static_cast<QRectF>(static_cast<QGraphicsLayoutItem*>(ptr)->contentsRect()).width(), static_cast<QRectF>(static_cast<QGraphicsLayoutItem*>(ptr)->contentsRect()).height());
}
void* QGraphicsLayoutItem_EffectiveSizeHint(void* ptr, int which, void* constraint)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsLayoutItem*>(ptr)->effectiveSizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).width(), static_cast<QSizeF>(static_cast<QGraphicsLayoutItem*>(ptr)->effectiveSizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).height());
}
void* QGraphicsLayoutItem_GraphicsItem(void* ptr)
{
return static_cast<QGraphicsLayoutItem*>(ptr)->graphicsItem();
}
int QGraphicsLayoutItem_IsLayout(void* ptr)
{
return static_cast<QGraphicsLayoutItem*>(ptr)->isLayout();
}
double QGraphicsLayoutItem_MaximumHeight(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsLayoutItem*>(ptr)->maximumHeight());
}
void* QGraphicsLayoutItem_MaximumSize(void* ptr)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsLayoutItem*>(ptr)->maximumSize()).width(), static_cast<QSizeF>(static_cast<QGraphicsLayoutItem*>(ptr)->maximumSize()).height());
}
double QGraphicsLayoutItem_MaximumWidth(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsLayoutItem*>(ptr)->maximumWidth());
}
double QGraphicsLayoutItem_MinimumHeight(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsLayoutItem*>(ptr)->minimumHeight());
}
void* QGraphicsLayoutItem_MinimumSize(void* ptr)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsLayoutItem*>(ptr)->minimumSize()).width(), static_cast<QSizeF>(static_cast<QGraphicsLayoutItem*>(ptr)->minimumSize()).height());
}
double QGraphicsLayoutItem_MinimumWidth(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsLayoutItem*>(ptr)->minimumWidth());
}
int 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<double>(static_cast<QGraphicsLayoutItem*>(ptr)->preferredHeight());
}
void* QGraphicsLayoutItem_PreferredSize(void* ptr)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsLayoutItem*>(ptr)->preferredSize()).width(), static_cast<QSizeF>(static_cast<QGraphicsLayoutItem*>(ptr)->preferredSize()).height());
}
double QGraphicsLayoutItem_PreferredWidth(void* ptr)
{
return static_cast<double>(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(static_cast<double>(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(static_cast<double>(w), static_cast<double>(h));
}
void QGraphicsLayoutItem_SetMaximumWidth(void* ptr, double width)
{
static_cast<QGraphicsLayoutItem*>(ptr)->setMaximumWidth(static_cast<double>(width));
}
void QGraphicsLayoutItem_SetMinimumHeight(void* ptr, double height)
{
static_cast<QGraphicsLayoutItem*>(ptr)->setMinimumHeight(static_cast<double>(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(static_cast<double>(w), static_cast<double>(h));
}
void QGraphicsLayoutItem_SetMinimumWidth(void* ptr, double width)
{
static_cast<QGraphicsLayoutItem*>(ptr)->setMinimumWidth(static_cast<double>(width));
}
void QGraphicsLayoutItem_SetOwnedByLayout(void* ptr, int 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(static_cast<double>(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(static_cast<double>(w), static_cast<double>(h));
}
void QGraphicsLayoutItem_SetPreferredWidth(void* ptr, double width)
{
static_cast<QGraphicsLayoutItem*>(ptr)->setPreferredWidth(static_cast<double>(width));
}
void QGraphicsLayoutItem_SetSizePolicy2(void* ptr, int hPolicy, int vPolicy, int 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, int which, void* constraint)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsLayoutItem*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).width(), static_cast<QSizeF>(static_cast<QGraphicsLayoutItem*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).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();
}
char* QGraphicsLayoutItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsLayoutItem*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
return static_cast<MyQGraphicsLayoutItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsLayoutItem_BASE").toUtf8().data();
}
void QGraphicsLayoutItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsLayoutItem*>(static_cast<QGraphicsLayoutItem*>(ptr))) {
static_cast<MyQGraphicsLayoutItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
class MyQGraphicsLineItem: public QGraphicsLineItem
{
public:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
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), this->objectNameAbs().toUtf8().data())); };
bool contains(const QPointF & point) const { return callbackQGraphicsLineItem_Contains(const_cast<MyQGraphicsLineItem*>(this), this->objectNameAbs().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsLineItem_IsObscuredBy(const_cast<MyQGraphicsLineItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsLineItem_OpaqueArea(const_cast<MyQGraphicsLineItem*>(this), this->objectNameAbs().toUtf8().data())); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsLineItem_Paint(this, this->objectNameAbs().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsLineItem_Shape(const_cast<MyQGraphicsLineItem*>(this), this->objectNameAbs().toUtf8().data())); };
int type() const { return callbackQGraphicsLineItem_Type(const_cast<MyQGraphicsLineItem*>(this), this->objectNameAbs().toUtf8().data()); };
void advance(int phase) { callbackQGraphicsLineItem_Advance(this, this->objectNameAbs().toUtf8().data(), phase); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsLineItem_CollidesWithItem(const_cast<MyQGraphicsLineItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsLineItem_CollidesWithPath(const_cast<MyQGraphicsLineItem*>(this), this->objectNameAbs().toUtf8().data(), new QPainterPath(path), mode) != 0; };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsLineItem_ContextMenuEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsLineItem_DragEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsLineItem_DragLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsLineItem_DragMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsLineItem_DropEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsLineItem_FocusInEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsLineItem_FocusOutEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsLineItem_HoverEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsLineItem_HoverLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsLineItem_HoverMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsLineItem_InputMethodEvent(this, this->objectNameAbs().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsLineItem_InputMethodQuery(const_cast<MyQGraphicsLineItem*>(this), this->objectNameAbs().toUtf8().data(), query)); };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsLineItem_ItemChange(this, this->objectNameAbs().toUtf8().data(), change, new QVariant(value))); };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsLineItem_KeyPressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsLineItem_KeyReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsLineItem_MouseDoubleClickEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsLineItem_MouseMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsLineItem_MousePressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsLineItem_MouseReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
bool sceneEvent(QEvent * event) { return callbackQGraphicsLineItem_SceneEvent(this, this->objectNameAbs().toUtf8().data(), event) != 0; };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsLineItem_SceneEventFilter(this, this->objectNameAbs().toUtf8().data(), watched, event) != 0; };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsLineItem_WheelEvent(this, this->objectNameAbs().toUtf8().data(), 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(static_cast<double>(x1), static_cast<double>(y1), static_cast<double>(x2), static_cast<double>(y2), static_cast<QGraphicsItem*>(parent));
}
void* QGraphicsLineItem_BoundingRect(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsLineItem*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsLineItem*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsLineItem*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsLineItem*>(ptr)->boundingRect()).height());
}
void* QGraphicsLineItem_BoundingRectDefault(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::boundingRect()).height());
}
int QGraphicsLineItem_Contains(void* ptr, void* point)
{
return static_cast<QGraphicsLineItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int QGraphicsLineItem_ContainsDefault(void* ptr, void* point)
{
return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::contains(*static_cast<QPointF*>(point));
}
int QGraphicsLineItem_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QGraphicsLineItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int QGraphicsLineItem_IsObscuredByDefault(void* ptr, void* item)
{
return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
}
void* QGraphicsLineItem_Line(void* ptr)
{
return new QLineF(static_cast<QLineF>(static_cast<QGraphicsLineItem*>(ptr)->line()).p1(), static_cast<QLineF>(static_cast<QGraphicsLineItem*>(ptr)->line()).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(static_cast<double>(x1), static_cast<double>(y1), static_cast<double>(x2), static_cast<double>(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();
}
char* QGraphicsLineItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsLineItem*>(static_cast<QGraphicsLineItem*>(ptr))) {
return static_cast<MyQGraphicsLineItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsLineItem_BASE").toUtf8().data();
}
void QGraphicsLineItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsLineItem*>(static_cast<QGraphicsLineItem*>(ptr))) {
static_cast<MyQGraphicsLineItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
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);
}
int QGraphicsLineItem_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsLineItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsLineItem_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsLineItem_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsLineItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsLineItem_CollidesWithPathDefault(void* ptr, void* path, int 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, int query)
{
return new QVariant(static_cast<QGraphicsLineItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsLineItem_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsLineItem_ItemChange(void* ptr, int 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, int 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));
}
int QGraphicsLineItem_SceneEvent(void* ptr, void* event)
{
return static_cast<QGraphicsLineItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsLineItem_SceneEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsLineItem*>(ptr)->QGraphicsLineItem::sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsLineItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsLineItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQGraphicsLinearLayout(QGraphicsLayoutItem *parent) : QGraphicsLinearLayout(parent) {};
MyQGraphicsLinearLayout(Qt::Orientation orientation, QGraphicsLayoutItem *parent) : QGraphicsLinearLayout(orientation, parent) {};
int count() const { return callbackQGraphicsLinearLayout_Count(const_cast<MyQGraphicsLinearLayout*>(this), this->objectNameAbs().toUtf8().data()); };
void invalidate() { callbackQGraphicsLinearLayout_Invalidate(this, this->objectNameAbs().toUtf8().data()); };
QGraphicsLayoutItem * itemAt(int index) const { return static_cast<QGraphicsLayoutItem*>(callbackQGraphicsLinearLayout_ItemAt(const_cast<MyQGraphicsLinearLayout*>(this), this->objectNameAbs().toUtf8().data(), index)); };
void removeAt(int index) { callbackQGraphicsLinearLayout_RemoveAt(this, this->objectNameAbs().toUtf8().data(), index); };
void setGeometry(const QRectF & rect) { callbackQGraphicsLinearLayout_SetGeometry(this, this->objectNameAbs().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height())); };
QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsLinearLayout_SizeHint(const_cast<MyQGraphicsLinearLayout*>(this), this->objectNameAbs().toUtf8().data(), which, new QSizeF(static_cast<QSizeF>(constraint).width(), static_cast<QSizeF>(constraint).height()))); };
void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsLinearLayout_GetContentsMargins(const_cast<MyQGraphicsLinearLayout*>(this), this->objectNameAbs().toUtf8().data(), *static_cast<double*>(left), *static_cast<double*>(top), *static_cast<double*>(right), *static_cast<double*>(bottom)); };
void updateGeometry() { callbackQGraphicsLinearLayout_UpdateGeometry(this, this->objectNameAbs().toUtf8().data()); };
void widgetEvent(QEvent * e) { callbackQGraphicsLinearLayout_WidgetEvent(this, this->objectNameAbs().toUtf8().data(), e); };
};
void* QGraphicsLinearLayout_NewQGraphicsLinearLayout(void* parent)
{
return new MyQGraphicsLinearLayout(static_cast<QGraphicsLayoutItem*>(parent));
}
void* QGraphicsLinearLayout_NewQGraphicsLinearLayout2(int 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);
}
int 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<double>(static_cast<QGraphicsLinearLayout*>(ptr)->itemSpacing(index));
}
int 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, int 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, static_cast<double>(spacing));
}
void QGraphicsLinearLayout_SetOrientation(void* ptr, int orientation)
{
static_cast<QGraphicsLinearLayout*>(ptr)->setOrientation(static_cast<Qt::Orientation>(orientation));
}
void QGraphicsLinearLayout_SetSpacing(void* ptr, double spacing)
{
static_cast<QGraphicsLinearLayout*>(ptr)->setSpacing(static_cast<double>(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, int which, void* constraint)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsLinearLayout*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).width(), static_cast<QSizeF>(static_cast<QGraphicsLinearLayout*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).height());
}
void* QGraphicsLinearLayout_SizeHintDefault(void* ptr, int which, void* constraint)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).width(), static_cast<QSizeF>(static_cast<QGraphicsLinearLayout*>(ptr)->QGraphicsLinearLayout::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).height());
}
double QGraphicsLinearLayout_Spacing(void* ptr)
{
return static_cast<double>(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();
}
char* QGraphicsLinearLayout_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsLinearLayout*>(static_cast<QGraphicsLinearLayout*>(ptr))) {
return static_cast<MyQGraphicsLinearLayout*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsLinearLayout_BASE").toUtf8().data();
}
void QGraphicsLinearLayout_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsLinearLayout*>(static_cast<QGraphicsLinearLayout*>(ptr))) {
static_cast<MyQGraphicsLinearLayout*>(ptr)->setObjectNameAbs(QString(name));
}
}
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, this->objectName().toUtf8().data()); };
void Signal_OpacityChanged() { callbackQGraphicsObject_OpacityChanged(this, this->objectName().toUtf8().data()); };
void Signal_ParentChanged() { callbackQGraphicsObject_ParentChanged(this, this->objectName().toUtf8().data()); };
void Signal_RotationChanged() { callbackQGraphicsObject_RotationChanged(this, this->objectName().toUtf8().data()); };
void Signal_ScaleChanged() { callbackQGraphicsObject_ScaleChanged(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQGraphicsObject_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void Signal_VisibleChanged() { callbackQGraphicsObject_VisibleChanged(this, this->objectName().toUtf8().data()); };
void Signal_XChanged() { callbackQGraphicsObject_XChanged(this, this->objectName().toUtf8().data()); };
void Signal_YChanged() { callbackQGraphicsObject_YChanged(this, this->objectName().toUtf8().data()); };
void Signal_ZChanged() { callbackQGraphicsObject_ZChanged(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsObject_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsObject_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsObject_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsObject_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsObject_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsObject_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsObject_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsObject_MetaObject(const_cast<MyQGraphicsObject*>(this), this->objectName().toUtf8().data())); };
void advance(int phase) { callbackQGraphicsObject_Advance(this, this->objectName().toUtf8().data(), phase); };
QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsObject_BoundingRect(const_cast<MyQGraphicsObject*>(this), this->objectName().toUtf8().data())); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsObject_CollidesWithItem(const_cast<MyQGraphicsObject*>(this), this->objectName().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsObject_CollidesWithPath(const_cast<MyQGraphicsObject*>(this), this->objectName().toUtf8().data(), new QPainterPath(path), mode) != 0; };
bool contains(const QPointF & point) const { return callbackQGraphicsObject_Contains(const_cast<MyQGraphicsObject*>(this), this->objectName().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsObject_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsObject_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsObject_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsObject_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsObject_DropEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsObject_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsObject_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsObject_HoverEnterEvent(this, this->objectName().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsObject_HoverLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsObject_HoverMoveEvent(this, this->objectName().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsObject_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsObject_InputMethodQuery(const_cast<MyQGraphicsObject*>(this), this->objectName().toUtf8().data(), query)); };
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsObject_IsObscuredBy(const_cast<MyQGraphicsObject*>(this), this->objectName().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsObject_ItemChange(this, this->objectName().toUtf8().data(), change, new QVariant(value))); };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsObject_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsObject_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsObject_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsObject_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsObject_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsObject_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsObject_OpaqueArea(const_cast<MyQGraphicsObject*>(this), this->objectName().toUtf8().data())); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsObject_Paint(this, this->objectName().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
bool sceneEvent(QEvent * event) { return callbackQGraphicsObject_SceneEvent(this, this->objectName().toUtf8().data(), event) != 0; };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsObject_SceneEventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsObject_Shape(const_cast<MyQGraphicsObject*>(this), this->objectName().toUtf8().data())); };
int type() const { return callbackQGraphicsObject_Type(const_cast<MyQGraphicsObject*>(this), this->objectName().toUtf8().data()); };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsObject_WheelEvent(this, this->objectName().toUtf8().data(), 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();
}
int QGraphicsObject_Event(void* ptr, void* ev)
{
return static_cast<QGraphicsObject*>(ptr)->event(static_cast<QEvent*>(ev));
}
void QGraphicsObject_GrabGesture(void* ptr, int gesture, int 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, int 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));
}
int QGraphicsObject_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsObject*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsObject*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsObject*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsObject*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsObject*>(ptr)->boundingRect()).height());
}
int QGraphicsObject_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsObject*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsObject_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsObject_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsObject*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsObject_CollidesWithPathDefault(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsObject_Contains(void* ptr, void* point)
{
return static_cast<QGraphicsObject*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int 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, int query)
{
return new QVariant(static_cast<QGraphicsObject*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsObject_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
int QGraphicsObject_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QGraphicsObject*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int QGraphicsObject_IsObscuredByDefault(void* ptr, void* item)
{
return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::isObscuredBy(static_cast<QGraphicsItem*>(item));
}
void* QGraphicsObject_ItemChange(void* ptr, int 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, int 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));
}
int QGraphicsObject_SceneEvent(void* ptr, void* event)
{
return static_cast<QGraphicsObject*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsObject_SceneEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsObject*>(ptr)->QGraphicsObject::sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsObject_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsObject*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), static_cast<double>(opacity)); };
void setOpacityMask(const QBrush & mask) { callbackQGraphicsOpacityEffect_SetOpacityMask(this, this->objectName().toUtf8().data(), new QBrush(mask)); };
void draw(QPainter * painter) { callbackQGraphicsOpacityEffect_Draw(this, this->objectName().toUtf8().data(), painter); };
void Signal_OpacityChanged(qreal opacity) { callbackQGraphicsOpacityEffect_OpacityChanged(this, this->objectName().toUtf8().data(), static_cast<double>(opacity)); };
void Signal_OpacityMaskChanged(const QBrush & mask) { callbackQGraphicsOpacityEffect_OpacityMaskChanged(this, this->objectName().toUtf8().data(), new QBrush(mask)); };
void setEnabled(bool enable) { callbackQGraphicsOpacityEffect_SetEnabled(this, this->objectName().toUtf8().data(), enable); };
QRectF boundingRectFor(const QRectF & rect) const { return *static_cast<QRectF*>(callbackQGraphicsOpacityEffect_BoundingRectFor(const_cast<MyQGraphicsOpacityEffect*>(this), this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height()))); };
void sourceChanged(QGraphicsEffect::ChangeFlags flags) { callbackQGraphicsOpacityEffect_SourceChanged(this, this->objectName().toUtf8().data(), flags); };
void update() { callbackQGraphicsOpacityEffect_Update(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsOpacityEffect_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsOpacityEffect_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsOpacityEffect_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsOpacityEffect_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsOpacityEffect_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsOpacityEffect_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQGraphicsOpacityEffect_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsOpacityEffect_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsOpacityEffect_MetaObject(const_cast<MyQGraphicsOpacityEffect*>(this), this->objectName().toUtf8().data())); };
};
double QGraphicsOpacityEffect_Opacity(void* ptr)
{
return static_cast<double>(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, static_cast<double>(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(static_cast<double>(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, int enable)
{
QMetaObject::invokeMethod(static_cast<QGraphicsOpacityEffect*>(ptr), "setEnabled", Q_ARG(bool, enable != 0));
}
void QGraphicsOpacityEffect_SetEnabledDefault(void* ptr, int enable)
{
static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::setEnabled(enable != 0);
}
void* QGraphicsOpacityEffect_BoundingRectFor(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsOpacityEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsOpacityEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsOpacityEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsOpacityEffect*>(ptr)->boundingRectFor(*static_cast<QRectF*>(rect))).height());
}
void* QGraphicsOpacityEffect_BoundingRectForDefault(void* ptr, void* rect)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::boundingRectFor(*static_cast<QRectF*>(rect))).x(), static_cast<QRectF>(static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::boundingRectFor(*static_cast<QRectF*>(rect))).y(), static_cast<QRectF>(static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::boundingRectFor(*static_cast<QRectF*>(rect))).width(), static_cast<QRectF>(static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::boundingRectFor(*static_cast<QRectF*>(rect))).height());
}
void QGraphicsOpacityEffect_SourceChanged(void* ptr, int flags)
{
static_cast<QGraphicsOpacityEffect*>(ptr)->sourceChanged(static_cast<QGraphicsEffect::ChangeFlag>(flags));
}
void QGraphicsOpacityEffect_SourceChangedDefault(void* ptr, int 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));
}
int QGraphicsOpacityEffect_Event(void* ptr, void* e)
{
return static_cast<QGraphicsOpacityEffect*>(ptr)->event(static_cast<QEvent*>(e));
}
int QGraphicsOpacityEffect_EventDefault(void* ptr, void* e)
{
return static_cast<QGraphicsOpacityEffect*>(ptr)->QGraphicsOpacityEffect::event(static_cast<QEvent*>(e));
}
int QGraphicsOpacityEffect_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsOpacityEffect*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
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), this->objectNameAbs().toUtf8().data())); };
bool contains(const QPointF & point) const { return callbackQGraphicsPathItem_Contains(const_cast<MyQGraphicsPathItem*>(this), this->objectNameAbs().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsPathItem_IsObscuredBy(const_cast<MyQGraphicsPathItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsPathItem_OpaqueArea(const_cast<MyQGraphicsPathItem*>(this), this->objectNameAbs().toUtf8().data())); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsPathItem_Paint(this, this->objectNameAbs().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsPathItem_Shape(const_cast<MyQGraphicsPathItem*>(this), this->objectNameAbs().toUtf8().data())); };
int type() const { return callbackQGraphicsPathItem_Type(const_cast<MyQGraphicsPathItem*>(this), this->objectNameAbs().toUtf8().data()); };
void advance(int phase) { callbackQGraphicsPathItem_Advance(this, this->objectNameAbs().toUtf8().data(), phase); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsPathItem_CollidesWithItem(const_cast<MyQGraphicsPathItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsPathItem_CollidesWithPath(const_cast<MyQGraphicsPathItem*>(this), this->objectNameAbs().toUtf8().data(), new QPainterPath(path), mode) != 0; };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsPathItem_ContextMenuEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPathItem_DragEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPathItem_DragLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPathItem_DragMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPathItem_DropEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsPathItem_FocusInEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsPathItem_FocusOutEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPathItem_HoverEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPathItem_HoverLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPathItem_HoverMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsPathItem_InputMethodEvent(this, this->objectNameAbs().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsPathItem_InputMethodQuery(const_cast<MyQGraphicsPathItem*>(this), this->objectNameAbs().toUtf8().data(), query)); };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsPathItem_ItemChange(this, this->objectNameAbs().toUtf8().data(), change, new QVariant(value))); };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsPathItem_KeyPressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsPathItem_KeyReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPathItem_MouseDoubleClickEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPathItem_MouseMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPathItem_MousePressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPathItem_MouseReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
bool sceneEvent(QEvent * event) { return callbackQGraphicsPathItem_SceneEvent(this, this->objectNameAbs().toUtf8().data(), event) != 0; };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsPathItem_SceneEventFilter(this, this->objectNameAbs().toUtf8().data(), watched, event) != 0; };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsPathItem_WheelEvent(this, this->objectNameAbs().toUtf8().data(), 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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsPathItem*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsPathItem*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsPathItem*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsPathItem*>(ptr)->boundingRect()).height());
}
void* QGraphicsPathItem_BoundingRectDefault(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::boundingRect()).height());
}
int QGraphicsPathItem_Contains(void* ptr, void* point)
{
return static_cast<QGraphicsPathItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int QGraphicsPathItem_ContainsDefault(void* ptr, void* point)
{
return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::contains(*static_cast<QPointF*>(point));
}
int QGraphicsPathItem_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QGraphicsPathItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int 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();
}
char* QGraphicsPathItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsPathItem*>(static_cast<QGraphicsPathItem*>(ptr))) {
return static_cast<MyQGraphicsPathItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsPathItem_BASE").toUtf8().data();
}
void QGraphicsPathItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsPathItem*>(static_cast<QGraphicsPathItem*>(ptr))) {
static_cast<MyQGraphicsPathItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
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);
}
int QGraphicsPathItem_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsPathItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsPathItem_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsPathItem_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsPathItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsPathItem_CollidesWithPathDefault(void* ptr, void* path, int 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, int query)
{
return new QVariant(static_cast<QGraphicsPathItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsPathItem_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsPathItem_ItemChange(void* ptr, int 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, int 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));
}
int QGraphicsPathItem_SceneEvent(void* ptr, void* event)
{
return static_cast<QGraphicsPathItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsPathItem_SceneEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsPathItem*>(ptr)->QGraphicsPathItem::sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsPathItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsPathItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
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), this->objectNameAbs().toUtf8().data())); };
bool contains(const QPointF & point) const { return callbackQGraphicsPixmapItem_Contains(const_cast<MyQGraphicsPixmapItem*>(this), this->objectNameAbs().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsPixmapItem_IsObscuredBy(const_cast<MyQGraphicsPixmapItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsPixmapItem_OpaqueArea(const_cast<MyQGraphicsPixmapItem*>(this), this->objectNameAbs().toUtf8().data())); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsPixmapItem_Paint(this, this->objectNameAbs().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsPixmapItem_Shape(const_cast<MyQGraphicsPixmapItem*>(this), this->objectNameAbs().toUtf8().data())); };
int type() const { return callbackQGraphicsPixmapItem_Type(const_cast<MyQGraphicsPixmapItem*>(this), this->objectNameAbs().toUtf8().data()); };
void advance(int phase) { callbackQGraphicsPixmapItem_Advance(this, this->objectNameAbs().toUtf8().data(), phase); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsPixmapItem_CollidesWithItem(const_cast<MyQGraphicsPixmapItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsPixmapItem_CollidesWithPath(const_cast<MyQGraphicsPixmapItem*>(this), this->objectNameAbs().toUtf8().data(), new QPainterPath(path), mode) != 0; };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsPixmapItem_ContextMenuEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPixmapItem_DragEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPixmapItem_DragLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPixmapItem_DragMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPixmapItem_DropEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsPixmapItem_FocusInEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsPixmapItem_FocusOutEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPixmapItem_HoverEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPixmapItem_HoverLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPixmapItem_HoverMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsPixmapItem_InputMethodEvent(this, this->objectNameAbs().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsPixmapItem_InputMethodQuery(const_cast<MyQGraphicsPixmapItem*>(this), this->objectNameAbs().toUtf8().data(), query)); };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsPixmapItem_ItemChange(this, this->objectNameAbs().toUtf8().data(), change, new QVariant(value))); };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsPixmapItem_KeyPressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsPixmapItem_KeyReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPixmapItem_MouseDoubleClickEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPixmapItem_MouseMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPixmapItem_MousePressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPixmapItem_MouseReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
bool sceneEvent(QEvent * event) { return callbackQGraphicsPixmapItem_SceneEvent(this, this->objectNameAbs().toUtf8().data(), event) != 0; };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsPixmapItem_SceneEventFilter(this, this->objectNameAbs().toUtf8().data(), watched, event) != 0; };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsPixmapItem_WheelEvent(this, this->objectNameAbs().toUtf8().data(), 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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsPixmapItem*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsPixmapItem*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsPixmapItem*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsPixmapItem*>(ptr)->boundingRect()).height());
}
void* QGraphicsPixmapItem_BoundingRectDefault(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::boundingRect()).height());
}
int QGraphicsPixmapItem_Contains(void* ptr, void* point)
{
return static_cast<QGraphicsPixmapItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int QGraphicsPixmapItem_ContainsDefault(void* ptr, void* point)
{
return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::contains(*static_cast<QPointF*>(point));
}
int QGraphicsPixmapItem_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QGraphicsPixmapItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int QGraphicsPixmapItem_IsObscuredByDefault(void* ptr, void* item)
{
return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::isObscuredBy(static_cast<QGraphicsItem*>(item));
}
void* QGraphicsPixmapItem_Offset(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsPixmapItem*>(ptr)->offset()).x(), static_cast<QPointF>(static_cast<QGraphicsPixmapItem*>(ptr)->offset()).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(static_cast<double>(x), static_cast<double>(y));
}
void QGraphicsPixmapItem_SetPixmap(void* ptr, void* pixmap)
{
static_cast<QGraphicsPixmapItem*>(ptr)->setPixmap(*static_cast<QPixmap*>(pixmap));
}
void QGraphicsPixmapItem_SetShapeMode(void* ptr, int mode)
{
static_cast<QGraphicsPixmapItem*>(ptr)->setShapeMode(static_cast<QGraphicsPixmapItem::ShapeMode>(mode));
}
void QGraphicsPixmapItem_SetTransformationMode(void* ptr, int 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());
}
int QGraphicsPixmapItem_ShapeMode(void* ptr)
{
return static_cast<QGraphicsPixmapItem*>(ptr)->shapeMode();
}
int 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();
}
char* QGraphicsPixmapItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsPixmapItem*>(static_cast<QGraphicsPixmapItem*>(ptr))) {
return static_cast<MyQGraphicsPixmapItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsPixmapItem_BASE").toUtf8().data();
}
void QGraphicsPixmapItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsPixmapItem*>(static_cast<QGraphicsPixmapItem*>(ptr))) {
static_cast<MyQGraphicsPixmapItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
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);
}
int QGraphicsPixmapItem_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsPixmapItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsPixmapItem_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsPixmapItem_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsPixmapItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsPixmapItem_CollidesWithPathDefault(void* ptr, void* path, int 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, int query)
{
return new QVariant(static_cast<QGraphicsPixmapItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsPixmapItem_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsPixmapItem_ItemChange(void* ptr, int 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, int 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));
}
int QGraphicsPixmapItem_SceneEvent(void* ptr, void* event)
{
return static_cast<QGraphicsPixmapItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsPixmapItem_SceneEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsPixmapItem*>(ptr)->QGraphicsPixmapItem::sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsPixmapItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsPixmapItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
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), this->objectNameAbs().toUtf8().data())); };
bool contains(const QPointF & point) const { return callbackQGraphicsPolygonItem_Contains(const_cast<MyQGraphicsPolygonItem*>(this), this->objectNameAbs().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsPolygonItem_IsObscuredBy(const_cast<MyQGraphicsPolygonItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsPolygonItem_OpaqueArea(const_cast<MyQGraphicsPolygonItem*>(this), this->objectNameAbs().toUtf8().data())); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsPolygonItem_Paint(this, this->objectNameAbs().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsPolygonItem_Shape(const_cast<MyQGraphicsPolygonItem*>(this), this->objectNameAbs().toUtf8().data())); };
int type() const { return callbackQGraphicsPolygonItem_Type(const_cast<MyQGraphicsPolygonItem*>(this), this->objectNameAbs().toUtf8().data()); };
void advance(int phase) { callbackQGraphicsPolygonItem_Advance(this, this->objectNameAbs().toUtf8().data(), phase); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsPolygonItem_CollidesWithItem(const_cast<MyQGraphicsPolygonItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsPolygonItem_CollidesWithPath(const_cast<MyQGraphicsPolygonItem*>(this), this->objectNameAbs().toUtf8().data(), new QPainterPath(path), mode) != 0; };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsPolygonItem_ContextMenuEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPolygonItem_DragEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPolygonItem_DragLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPolygonItem_DragMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsPolygonItem_DropEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsPolygonItem_FocusInEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsPolygonItem_FocusOutEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPolygonItem_HoverEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPolygonItem_HoverLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsPolygonItem_HoverMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsPolygonItem_InputMethodEvent(this, this->objectNameAbs().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsPolygonItem_InputMethodQuery(const_cast<MyQGraphicsPolygonItem*>(this), this->objectNameAbs().toUtf8().data(), query)); };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsPolygonItem_ItemChange(this, this->objectNameAbs().toUtf8().data(), change, new QVariant(value))); };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsPolygonItem_KeyPressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsPolygonItem_KeyReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPolygonItem_MouseDoubleClickEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPolygonItem_MouseMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPolygonItem_MousePressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsPolygonItem_MouseReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
bool sceneEvent(QEvent * event) { return callbackQGraphicsPolygonItem_SceneEvent(this, this->objectNameAbs().toUtf8().data(), event) != 0; };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsPolygonItem_SceneEventFilter(this, this->objectNameAbs().toUtf8().data(), watched, event) != 0; };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsPolygonItem_WheelEvent(this, this->objectNameAbs().toUtf8().data(), 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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsPolygonItem*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsPolygonItem*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsPolygonItem*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsPolygonItem*>(ptr)->boundingRect()).height());
}
void* QGraphicsPolygonItem_BoundingRectDefault(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::boundingRect()).height());
}
int QGraphicsPolygonItem_Contains(void* ptr, void* point)
{
return static_cast<QGraphicsPolygonItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int QGraphicsPolygonItem_ContainsDefault(void* ptr, void* point)
{
return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::contains(*static_cast<QPointF*>(point));
}
int QGraphicsPolygonItem_FillRule(void* ptr)
{
return static_cast<QGraphicsPolygonItem*>(ptr)->fillRule();
}
int QGraphicsPolygonItem_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QGraphicsPolygonItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int 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, int 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();
}
char* QGraphicsPolygonItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsPolygonItem*>(static_cast<QGraphicsPolygonItem*>(ptr))) {
return static_cast<MyQGraphicsPolygonItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsPolygonItem_BASE").toUtf8().data();
}
void QGraphicsPolygonItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsPolygonItem*>(static_cast<QGraphicsPolygonItem*>(ptr))) {
static_cast<MyQGraphicsPolygonItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
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);
}
int QGraphicsPolygonItem_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsPolygonItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsPolygonItem_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsPolygonItem_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsPolygonItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsPolygonItem_CollidesWithPathDefault(void* ptr, void* path, int 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, int query)
{
return new QVariant(static_cast<QGraphicsPolygonItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsPolygonItem_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsPolygonItem_ItemChange(void* ptr, int 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, int 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));
}
int QGraphicsPolygonItem_SceneEvent(void* ptr, void* event)
{
return static_cast<QGraphicsPolygonItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsPolygonItem_SceneEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsPolygonItem*>(ptr)->QGraphicsPolygonItem::sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsPolygonItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsPolygonItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), const_cast<QWidget*>(child))); };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsProxyWidget_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsProxyWidget_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsProxyWidget_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsProxyWidget_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsProxyWidget_DropEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsProxyWidget_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQGraphicsProxyWidget_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsProxyWidget_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void grabMouseEvent(QEvent * event) { callbackQGraphicsProxyWidget_GrabMouseEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQGraphicsProxyWidget_HideEvent(this, this->objectName().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsProxyWidget_HoverEnterEvent(this, this->objectName().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsProxyWidget_HoverLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsProxyWidget_HoverMoveEvent(this, this->objectName().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsProxyWidget_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsProxyWidget_InputMethodQuery(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data(), query)); };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsProxyWidget_ItemChange(this, this->objectName().toUtf8().data(), change, new QVariant(value))); };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsProxyWidget_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsProxyWidget_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsProxyWidget_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsProxyWidget_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsProxyWidget_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsProxyWidget_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsProxyWidget_Paint(this, this->objectName().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
void resizeEvent(QGraphicsSceneResizeEvent * event) { callbackQGraphicsProxyWidget_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setGeometry(const QRectF & rect) { callbackQGraphicsProxyWidget_SetGeometry(this, this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height())); };
void showEvent(QShowEvent * event) { callbackQGraphicsProxyWidget_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsProxyWidget_SizeHint(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data(), which, new QSizeF(static_cast<QSizeF>(constraint).width(), static_cast<QSizeF>(constraint).height()))); };
int type() const { return callbackQGraphicsProxyWidget_Type(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data()); };
void ungrabMouseEvent(QEvent * event) { callbackQGraphicsProxyWidget_UngrabMouseEvent(this, this->objectName().toUtf8().data(), event); };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsProxyWidget_WheelEvent(this, this->objectName().toUtf8().data(), event); };
QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsProxyWidget_BoundingRect(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * event) { callbackQGraphicsProxyWidget_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQGraphicsProxyWidget_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQGraphicsProxyWidget_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsProxyWidget_GetContentsMargins(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data(), *static_cast<double*>(left), *static_cast<double*>(top), *static_cast<double*>(right), *static_cast<double*>(bottom)); };
void grabKeyboardEvent(QEvent * event) { callbackQGraphicsProxyWidget_GrabKeyboardEvent(this, this->objectName().toUtf8().data(), event); };
void initStyleOption(QStyleOption * option) const { callbackQGraphicsProxyWidget_InitStyleOption(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data(), option); };
void moveEvent(QGraphicsSceneMoveEvent * event) { callbackQGraphicsProxyWidget_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintWindowFrame(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsProxyWidget_PaintWindowFrame(this, this->objectName().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
void polishEvent() { callbackQGraphicsProxyWidget_PolishEvent(this, this->objectName().toUtf8().data()); };
bool sceneEvent(QEvent * event) { return callbackQGraphicsProxyWidget_SceneEvent(this, this->objectName().toUtf8().data(), event) != 0; };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsProxyWidget_Shape(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data())); };
void ungrabKeyboardEvent(QEvent * event) { callbackQGraphicsProxyWidget_UngrabKeyboardEvent(this, this->objectName().toUtf8().data(), event); };
void updateGeometry() { callbackQGraphicsProxyWidget_UpdateGeometry(this, this->objectName().toUtf8().data()); };
bool windowFrameEvent(QEvent * event) { return callbackQGraphicsProxyWidget_WindowFrameEvent(this, this->objectName().toUtf8().data(), event) != 0; };
Qt::WindowFrameSection windowFrameSectionAt(const QPointF & pos) const { return static_cast<Qt::WindowFrameSection>(callbackQGraphicsProxyWidget_WindowFrameSectionAt(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data(), new QPointF(static_cast<QPointF>(pos).x(), static_cast<QPointF>(pos).y()))); };
void updateMicroFocus() { callbackQGraphicsProxyWidget_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsProxyWidget_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsProxyWidget_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsProxyWidget_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsProxyWidget_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsProxyWidget_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsProxyWidget_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsProxyWidget_MetaObject(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data())); };
void advance(int phase) { callbackQGraphicsProxyWidget_Advance(this, this->objectName().toUtf8().data(), phase); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsProxyWidget_CollidesWithItem(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsProxyWidget_CollidesWithPath(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data(), new QPainterPath(path), mode) != 0; };
bool contains(const QPointF & point) const { return callbackQGraphicsProxyWidget_Contains(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsProxyWidget_IsObscuredBy(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsProxyWidget_OpaqueArea(const_cast<MyQGraphicsProxyWidget*>(this), this->objectName().toUtf8().data())); };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsProxyWidget_SceneEventFilter(this, this->objectName().toUtf8().data(), 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, int 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));
}
int QGraphicsProxyWidget_Event(void* ptr, void* event)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->event(static_cast<QEvent*>(event));
}
int 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));
}
int QGraphicsProxyWidget_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->focusNextPrevChild(next != 0);
}
int QGraphicsProxyWidget_FocusNextPrevChildDefault(void* ptr, int 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, int query)
{
return new QVariant(static_cast<QGraphicsProxyWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsProxyWidget_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsProxyWidget_ItemChange(void* ptr, int 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, int 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, int which, void* constraint)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsProxyWidget*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).width(), static_cast<QSizeF>(static_cast<QGraphicsProxyWidget*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).height());
}
void* QGraphicsProxyWidget_SizeHintDefault(void* ptr, int which, void* constraint)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).width(), static_cast<QSizeF>(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).height());
}
void* QGraphicsProxyWidget_SubWidgetRect(void* ptr, void* widget)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsProxyWidget*>(ptr)->subWidgetRect(static_cast<QWidget*>(widget))).x(), static_cast<QRectF>(static_cast<QGraphicsProxyWidget*>(ptr)->subWidgetRect(static_cast<QWidget*>(widget))).y(), static_cast<QRectF>(static_cast<QGraphicsProxyWidget*>(ptr)->subWidgetRect(static_cast<QWidget*>(widget))).width(), static_cast<QRectF>(static_cast<QGraphicsProxyWidget*>(ptr)->subWidgetRect(static_cast<QWidget*>(widget))).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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsProxyWidget*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsProxyWidget*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsProxyWidget*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsProxyWidget*>(ptr)->boundingRect()).height());
}
void* QGraphicsProxyWidget_BoundingRectDefault(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::boundingRect()).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));
}
int QGraphicsProxyWidget_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QGraphicsProxyWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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_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();
}
int QGraphicsProxyWidget_SceneEvent(void* ptr, void* event)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int 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();
}
int QGraphicsProxyWidget_WindowFrameEvent(void* ptr, void* event)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->windowFrameEvent(static_cast<QEvent*>(event));
}
int QGraphicsProxyWidget_WindowFrameEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::windowFrameEvent(static_cast<QEvent*>(event));
}
int QGraphicsProxyWidget_WindowFrameSectionAt(void* ptr, void* pos)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->windowFrameSectionAt(*static_cast<QPointF*>(pos));
}
int 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);
}
int QGraphicsProxyWidget_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsProxyWidget_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsProxyWidget_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsProxyWidget_CollidesWithPathDefault(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsProxyWidget_Contains(void* ptr, void* point)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int QGraphicsProxyWidget_ContainsDefault(void* ptr, void* point)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->QGraphicsProxyWidget::contains(*static_cast<QPointF*>(point));
}
int QGraphicsProxyWidget_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int 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());
}
int QGraphicsProxyWidget_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsProxyWidget*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
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), this->objectNameAbs().toUtf8().data())); };
bool contains(const QPointF & point) const { return callbackQGraphicsRectItem_Contains(const_cast<MyQGraphicsRectItem*>(this), this->objectNameAbs().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsRectItem_IsObscuredBy(const_cast<MyQGraphicsRectItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsRectItem_OpaqueArea(const_cast<MyQGraphicsRectItem*>(this), this->objectNameAbs().toUtf8().data())); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsRectItem_Paint(this, this->objectNameAbs().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsRectItem_Shape(const_cast<MyQGraphicsRectItem*>(this), this->objectNameAbs().toUtf8().data())); };
int type() const { return callbackQGraphicsRectItem_Type(const_cast<MyQGraphicsRectItem*>(this), this->objectNameAbs().toUtf8().data()); };
void advance(int phase) { callbackQGraphicsRectItem_Advance(this, this->objectNameAbs().toUtf8().data(), phase); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsRectItem_CollidesWithItem(const_cast<MyQGraphicsRectItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsRectItem_CollidesWithPath(const_cast<MyQGraphicsRectItem*>(this), this->objectNameAbs().toUtf8().data(), new QPainterPath(path), mode) != 0; };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsRectItem_ContextMenuEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsRectItem_DragEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsRectItem_DragLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsRectItem_DragMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsRectItem_DropEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsRectItem_FocusInEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsRectItem_FocusOutEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsRectItem_HoverEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsRectItem_HoverLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsRectItem_HoverMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsRectItem_InputMethodEvent(this, this->objectNameAbs().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsRectItem_InputMethodQuery(const_cast<MyQGraphicsRectItem*>(this), this->objectNameAbs().toUtf8().data(), query)); };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsRectItem_ItemChange(this, this->objectNameAbs().toUtf8().data(), change, new QVariant(value))); };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsRectItem_KeyPressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsRectItem_KeyReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsRectItem_MouseDoubleClickEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsRectItem_MouseMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsRectItem_MousePressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsRectItem_MouseReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
bool sceneEvent(QEvent * event) { return callbackQGraphicsRectItem_SceneEvent(this, this->objectNameAbs().toUtf8().data(), event) != 0; };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsRectItem_SceneEventFilter(this, this->objectNameAbs().toUtf8().data(), watched, event) != 0; };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsRectItem_WheelEvent(this, this->objectNameAbs().toUtf8().data(), event); };
};
void* QGraphicsRectItem_NewQGraphicsRectItem3(double x, double y, double width, double height, void* parent)
{
return new MyQGraphicsRectItem(static_cast<double>(x), static_cast<double>(y), static_cast<double>(width), static_cast<double>(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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsRectItem*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsRectItem*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsRectItem*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsRectItem*>(ptr)->boundingRect()).height());
}
void* QGraphicsRectItem_BoundingRectDefault(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::boundingRect()).height());
}
int QGraphicsRectItem_Contains(void* ptr, void* point)
{
return static_cast<QGraphicsRectItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int QGraphicsRectItem_ContainsDefault(void* ptr, void* point)
{
return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::contains(*static_cast<QPointF*>(point));
}
int QGraphicsRectItem_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QGraphicsRectItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int 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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsRectItem*>(ptr)->rect()).x(), static_cast<QRectF>(static_cast<QGraphicsRectItem*>(ptr)->rect()).y(), static_cast<QRectF>(static_cast<QGraphicsRectItem*>(ptr)->rect()).width(), static_cast<QRectF>(static_cast<QGraphicsRectItem*>(ptr)->rect()).height());
}
void QGraphicsRectItem_SetRect2(void* ptr, double x, double y, double width, double height)
{
static_cast<QGraphicsRectItem*>(ptr)->setRect(static_cast<double>(x), static_cast<double>(y), static_cast<double>(width), static_cast<double>(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();
}
char* QGraphicsRectItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsRectItem*>(static_cast<QGraphicsRectItem*>(ptr))) {
return static_cast<MyQGraphicsRectItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsRectItem_BASE").toUtf8().data();
}
void QGraphicsRectItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsRectItem*>(static_cast<QGraphicsRectItem*>(ptr))) {
static_cast<MyQGraphicsRectItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
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);
}
int QGraphicsRectItem_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsRectItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsRectItem_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsRectItem_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsRectItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsRectItem_CollidesWithPathDefault(void* ptr, void* path, int 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, int query)
{
return new QVariant(static_cast<QGraphicsRectItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsRectItem_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsRectItem_ItemChange(void* ptr, int 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, int 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));
}
int QGraphicsRectItem_SceneEvent(void* ptr, void* event)
{
return static_cast<QGraphicsRectItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsRectItem_SceneEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsRectItem*>(ptr)->QGraphicsRectItem::sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsRectItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsRectItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data()); };
void applyTo(QMatrix4x4 * matrix) const { callbackQGraphicsRotation_ApplyTo(const_cast<MyQGraphicsRotation*>(this), this->objectName().toUtf8().data(), matrix); };
void Signal_AxisChanged() { callbackQGraphicsRotation_AxisChanged(this, this->objectName().toUtf8().data()); };
void Signal_OriginChanged() { callbackQGraphicsRotation_OriginChanged(this, this->objectName().toUtf8().data()); };
void update() { callbackQGraphicsRotation_Update(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsRotation_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsRotation_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsRotation_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsRotation_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsRotation_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsRotation_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQGraphicsRotation_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsRotation_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsRotation_MetaObject(const_cast<MyQGraphicsRotation*>(this), this->objectName().toUtf8().data())); };
};
double QGraphicsRotation_Angle(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsRotation*>(ptr)->angle());
}
void QGraphicsRotation_SetAngle(void* ptr, double vqr)
{
static_cast<QGraphicsRotation*>(ptr)->setAngle(static_cast<double>(vqr));
}
void QGraphicsRotation_SetAxis2(void* ptr, int 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));
}
int QGraphicsRotation_Event(void* ptr, void* e)
{
return static_cast<QGraphicsRotation*>(ptr)->event(static_cast<QEvent*>(e));
}
int QGraphicsRotation_EventDefault(void* ptr, void* e)
{
return static_cast<QGraphicsRotation*>(ptr)->QGraphicsRotation::event(static_cast<QEvent*>(e));
}
int QGraphicsRotation_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsRotation*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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), this->objectName().toUtf8().data(), matrix); };
void Signal_OriginChanged() { callbackQGraphicsScale_OriginChanged(this, this->objectName().toUtf8().data()); };
void Signal_ScaleChanged() { callbackQGraphicsScale_ScaleChanged(this, this->objectName().toUtf8().data()); };
void Signal_XScaleChanged() { callbackQGraphicsScale_XScaleChanged(this, this->objectName().toUtf8().data()); };
void Signal_YScaleChanged() { callbackQGraphicsScale_YScaleChanged(this, this->objectName().toUtf8().data()); };
void Signal_ZScaleChanged() { callbackQGraphicsScale_ZScaleChanged(this, this->objectName().toUtf8().data()); };
void update() { callbackQGraphicsScale_Update(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsScale_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsScale_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsScale_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsScale_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsScale_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsScale_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQGraphicsScale_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsScale_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsScale_MetaObject(const_cast<MyQGraphicsScale*>(this), this->objectName().toUtf8().data())); };
};
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(static_cast<double>(vqr));
}
void QGraphicsScale_SetYScale(void* ptr, double vqr)
{
static_cast<QGraphicsScale*>(ptr)->setYScale(static_cast<double>(vqr));
}
void QGraphicsScale_SetZScale(void* ptr, double vqr)
{
static_cast<QGraphicsScale*>(ptr)->setZScale(static_cast<double>(vqr));
}
double QGraphicsScale_XScale(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsScale*>(ptr)->xScale());
}
double QGraphicsScale_YScale(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsScale*>(ptr)->yScale());
}
double QGraphicsScale_ZScale(void* ptr)
{
return static_cast<double>(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));
}
int QGraphicsScale_Event(void* ptr, void* e)
{
return static_cast<QGraphicsScale*>(ptr)->event(static_cast<QEvent*>(e));
}
int QGraphicsScale_EventDefault(void* ptr, void* e)
{
return static_cast<QGraphicsScale*>(ptr)->QGraphicsScale::event(static_cast<QEvent*>(e));
}
int QGraphicsScale_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsScale*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height())); };
void advance() { callbackQGraphicsScene_Advance(this, this->objectName().toUtf8().data()); };
void clear() { callbackQGraphicsScene_Clear(this, this->objectName().toUtf8().data()); };
void clearSelection() { callbackQGraphicsScene_ClearSelection(this, this->objectName().toUtf8().data()); };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * contextMenuEvent) { callbackQGraphicsScene_ContextMenuEvent(this, this->objectName().toUtf8().data(), contextMenuEvent); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsScene_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsScene_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsScene_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void drawBackground(QPainter * painter, const QRectF & rect) { callbackQGraphicsScene_DrawBackground(this, this->objectName().toUtf8().data(), painter, new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height())); };
void drawForeground(QPainter * painter, const QRectF & rect) { callbackQGraphicsScene_DrawForeground(this, this->objectName().toUtf8().data(), painter, new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height())); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsScene_DropEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * focusEvent) { callbackQGraphicsScene_FocusInEvent(this, this->objectName().toUtf8().data(), focusEvent); };
void Signal_FocusItemChanged(QGraphicsItem * newFocusItem, QGraphicsItem * oldFocusItem, Qt::FocusReason reason) { callbackQGraphicsScene_FocusItemChanged(this, this->objectName().toUtf8().data(), newFocusItem, oldFocusItem, reason); };
bool focusNextPrevChild(bool next) { return callbackQGraphicsScene_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * focusEvent) { callbackQGraphicsScene_FocusOutEvent(this, this->objectName().toUtf8().data(), focusEvent); };
void helpEvent(QGraphicsSceneHelpEvent * helpEvent) { callbackQGraphicsScene_HelpEvent(this, this->objectName().toUtf8().data(), helpEvent); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsScene_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsScene_InputMethodQuery(const_cast<MyQGraphicsScene*>(this), this->objectName().toUtf8().data(), query)); };
void invalidate(const QRectF & rect, QGraphicsScene::SceneLayers layers) { callbackQGraphicsScene_Invalidate(this, this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height()), layers); };
void keyPressEvent(QKeyEvent * keyEvent) { callbackQGraphicsScene_KeyPressEvent(this, this->objectName().toUtf8().data(), keyEvent); };
void keyReleaseEvent(QKeyEvent * keyEvent) { callbackQGraphicsScene_KeyReleaseEvent(this, this->objectName().toUtf8().data(), keyEvent); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * mouseEvent) { callbackQGraphicsScene_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), mouseEvent); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * mouseEvent) { callbackQGraphicsScene_MouseMoveEvent(this, this->objectName().toUtf8().data(), mouseEvent); };
void mousePressEvent(QGraphicsSceneMouseEvent * mouseEvent) { callbackQGraphicsScene_MousePressEvent(this, this->objectName().toUtf8().data(), mouseEvent); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * mouseEvent) { callbackQGraphicsScene_MouseReleaseEvent(this, this->objectName().toUtf8().data(), mouseEvent); };
void Signal_SceneRectChanged(const QRectF & rect) { callbackQGraphicsScene_SceneRectChanged(this, this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height())); };
void Signal_SelectionChanged() { callbackQGraphicsScene_SelectionChanged(this, this->objectName().toUtf8().data()); };
void wheelEvent(QGraphicsSceneWheelEvent * wheelEvent) { callbackQGraphicsScene_WheelEvent(this, this->objectName().toUtf8().data(), wheelEvent); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsScene_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsScene_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsScene_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsScene_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsScene_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsScene_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsScene_MetaObject(const_cast<MyQGraphicsScene*>(this), this->objectName().toUtf8().data())); };
};
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());
}
int QGraphicsScene_IsSortCacheEnabled(void* ptr)
{
return static_cast<QGraphicsScene*>(ptr)->isSortCacheEnabled();
}
int QGraphicsScene_ItemIndexMethod(void* ptr)
{
return static_cast<QGraphicsScene*>(ptr)->itemIndexMethod();
}
double QGraphicsScene_MinimumRenderSize(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsScene*>(ptr)->minimumRenderSize());
}
void* QGraphicsScene_Palette(void* ptr)
{
return new QPalette(static_cast<QGraphicsScene*>(ptr)->palette());
}
void* QGraphicsScene_SceneRect(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsScene*>(ptr)->sceneRect()).x(), static_cast<QRectF>(static_cast<QGraphicsScene*>(ptr)->sceneRect()).y(), static_cast<QRectF>(static_cast<QGraphicsScene*>(ptr)->sceneRect()).width(), static_cast<QRectF>(static_cast<QGraphicsScene*>(ptr)->sceneRect()).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, int method)
{
static_cast<QGraphicsScene*>(ptr)->setItemIndexMethod(static_cast<QGraphicsScene::ItemIndexMethod>(method));
}
void QGraphicsScene_SetMinimumRenderSize(void* ptr, double minSize)
{
static_cast<QGraphicsScene*>(ptr)->setMinimumRenderSize(static_cast<double>(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, int enabled)
{
static_cast<QGraphicsScene*>(ptr)->setSortCacheEnabled(enabled != 0);
}
void QGraphicsScene_SetStickyFocus(void* ptr, int enabled)
{
static_cast<QGraphicsScene*>(ptr)->setStickyFocus(enabled != 0);
}
int 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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(width), static_cast<double>(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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(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(static_cast<double>(x1), static_cast<double>(y1), static_cast<double>(x2), static_cast<double>(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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(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, int 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));
}
int QGraphicsScene_Event(void* ptr, void* event)
{
return static_cast<QGraphicsScene*>(ptr)->event(static_cast<QEvent*>(event));
}
int 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, int reason)
{
static_cast<QGraphicsScene*>(ptr)->focusItemChanged(static_cast<QGraphicsItem*>(newFocusItem), static_cast<QGraphicsItem*>(oldFocusItem), static_cast<Qt::FocusReason>(reason));
}
int QGraphicsScene_FocusNextPrevChild(void* ptr, int next)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QGraphicsScene*>(ptr), "focusNextPrevChild", Q_RETURN_ARG(bool, returnArg), Q_ARG(bool, next != 0));
return returnArg;
}
int QGraphicsScene_FocusNextPrevChildDefault(void* ptr, int 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));
}
int QGraphicsScene_HasFocus(void* ptr)
{
return static_cast<QGraphicsScene*>(ptr)->hasFocus();
}
double QGraphicsScene_Height(void* ptr)
{
return static_cast<double>(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, int query)
{
return new QVariant(static_cast<QGraphicsScene*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsScene_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsScene*>(ptr)->QGraphicsScene::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void QGraphicsScene_Invalidate(void* ptr, void* rect, int 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, int layers)
{
static_cast<QGraphicsScene*>(ptr)->invalidate(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h), static_cast<QGraphicsScene::SceneLayer>(layers));
}
int 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(static_cast<double>(x), static_cast<double>(y), *static_cast<QTransform*>(deviceTransform));
}
void* QGraphicsScene_ItemsBoundingRect(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsScene*>(ptr)->itemsBoundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsScene*>(ptr)->itemsBoundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsScene*>(ptr)->itemsBoundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsScene*>(ptr)->itemsBoundingRect()).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, int 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();
}
int 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, int focusReason)
{
static_cast<QGraphicsScene*>(ptr)->setFocus(static_cast<Qt::FocusReason>(focusReason));
}
void QGraphicsScene_SetFocusItem(void* ptr, void* item, int 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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h));
}
void QGraphicsScene_SetSelectionArea2(void* ptr, void* path, int 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, int selectionOperation, int 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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(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<double>(static_cast<QGraphicsScene*>(ptr)->width());
}
void QGraphicsScene_DestroyQGraphicsScene(void* ptr)
{
static_cast<QGraphicsScene*>(ptr)->~QGraphicsScene();
}
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());
}
int QGraphicsSceneContextMenuEvent_Modifiers(void* ptr)
{
return static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->modifiers();
}
void* QGraphicsSceneContextMenuEvent_Pos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->pos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->pos()).y());
}
int QGraphicsSceneContextMenuEvent_Reason(void* ptr)
{
return static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->reason();
}
void* QGraphicsSceneContextMenuEvent_ScenePos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->scenePos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->scenePos()).y());
}
void* QGraphicsSceneContextMenuEvent_ScreenPos(void* ptr)
{
return new QPoint(static_cast<QPoint>(static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->screenPos()).x(), static_cast<QPoint>(static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->screenPos()).y());
}
void QGraphicsSceneContextMenuEvent_DestroyQGraphicsSceneContextMenuEvent(void* ptr)
{
static_cast<QGraphicsSceneContextMenuEvent*>(ptr)->~QGraphicsSceneContextMenuEvent();
}
void QGraphicsSceneDragDropEvent_AcceptProposedAction(void* ptr)
{
static_cast<QGraphicsSceneDragDropEvent*>(ptr)->acceptProposedAction();
}
int QGraphicsSceneDragDropEvent_Buttons(void* ptr)
{
return static_cast<QGraphicsSceneDragDropEvent*>(ptr)->buttons();
}
int QGraphicsSceneDragDropEvent_DropAction(void* ptr)
{
return static_cast<QGraphicsSceneDragDropEvent*>(ptr)->dropAction();
}
void* QGraphicsSceneDragDropEvent_MimeData(void* ptr)
{
return const_cast<QMimeData*>(static_cast<QGraphicsSceneDragDropEvent*>(ptr)->mimeData());
}
int QGraphicsSceneDragDropEvent_Modifiers(void* ptr)
{
return static_cast<QGraphicsSceneDragDropEvent*>(ptr)->modifiers();
}
void* QGraphicsSceneDragDropEvent_Pos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneDragDropEvent*>(ptr)->pos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneDragDropEvent*>(ptr)->pos()).y());
}
int QGraphicsSceneDragDropEvent_PossibleActions(void* ptr)
{
return static_cast<QGraphicsSceneDragDropEvent*>(ptr)->possibleActions();
}
int QGraphicsSceneDragDropEvent_ProposedAction(void* ptr)
{
return static_cast<QGraphicsSceneDragDropEvent*>(ptr)->proposedAction();
}
void* QGraphicsSceneDragDropEvent_ScenePos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneDragDropEvent*>(ptr)->scenePos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneDragDropEvent*>(ptr)->scenePos()).y());
}
void* QGraphicsSceneDragDropEvent_ScreenPos(void* ptr)
{
return new QPoint(static_cast<QPoint>(static_cast<QGraphicsSceneDragDropEvent*>(ptr)->screenPos()).x(), static_cast<QPoint>(static_cast<QGraphicsSceneDragDropEvent*>(ptr)->screenPos()).y());
}
void QGraphicsSceneDragDropEvent_SetDropAction(void* ptr, int 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 new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneHelpEvent*>(ptr)->scenePos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneHelpEvent*>(ptr)->scenePos()).y());
}
void* QGraphicsSceneHelpEvent_ScreenPos(void* ptr)
{
return new QPoint(static_cast<QPoint>(static_cast<QGraphicsSceneHelpEvent*>(ptr)->screenPos()).x(), static_cast<QPoint>(static_cast<QGraphicsSceneHelpEvent*>(ptr)->screenPos()).y());
}
void QGraphicsSceneHelpEvent_DestroyQGraphicsSceneHelpEvent(void* ptr)
{
static_cast<QGraphicsSceneHelpEvent*>(ptr)->~QGraphicsSceneHelpEvent();
}
void* QGraphicsSceneHoverEvent_LastPos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneHoverEvent*>(ptr)->lastPos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneHoverEvent*>(ptr)->lastPos()).y());
}
void* QGraphicsSceneHoverEvent_LastScenePos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneHoverEvent*>(ptr)->lastScenePos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneHoverEvent*>(ptr)->lastScenePos()).y());
}
void* QGraphicsSceneHoverEvent_LastScreenPos(void* ptr)
{
return new QPoint(static_cast<QPoint>(static_cast<QGraphicsSceneHoverEvent*>(ptr)->lastScreenPos()).x(), static_cast<QPoint>(static_cast<QGraphicsSceneHoverEvent*>(ptr)->lastScreenPos()).y());
}
int QGraphicsSceneHoverEvent_Modifiers(void* ptr)
{
return static_cast<QGraphicsSceneHoverEvent*>(ptr)->modifiers();
}
void* QGraphicsSceneHoverEvent_Pos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneHoverEvent*>(ptr)->pos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneHoverEvent*>(ptr)->pos()).y());
}
void* QGraphicsSceneHoverEvent_ScenePos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneHoverEvent*>(ptr)->scenePos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneHoverEvent*>(ptr)->scenePos()).y());
}
void* QGraphicsSceneHoverEvent_ScreenPos(void* ptr)
{
return new QPoint(static_cast<QPoint>(static_cast<QGraphicsSceneHoverEvent*>(ptr)->screenPos()).x(), static_cast<QPoint>(static_cast<QGraphicsSceneHoverEvent*>(ptr)->screenPos()).y());
}
void QGraphicsSceneHoverEvent_DestroyQGraphicsSceneHoverEvent(void* ptr)
{
static_cast<QGraphicsSceneHoverEvent*>(ptr)->~QGraphicsSceneHoverEvent();
}
int QGraphicsSceneMouseEvent_Button(void* ptr)
{
return static_cast<QGraphicsSceneMouseEvent*>(ptr)->button();
}
void* QGraphicsSceneMouseEvent_ButtonDownPos(void* ptr, int button)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->buttonDownPos(static_cast<Qt::MouseButton>(button))).x(), static_cast<QPointF>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->buttonDownPos(static_cast<Qt::MouseButton>(button))).y());
}
void* QGraphicsSceneMouseEvent_ButtonDownScenePos(void* ptr, int button)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->buttonDownScenePos(static_cast<Qt::MouseButton>(button))).x(), static_cast<QPointF>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->buttonDownScenePos(static_cast<Qt::MouseButton>(button))).y());
}
void* QGraphicsSceneMouseEvent_ButtonDownScreenPos(void* ptr, int button)
{
return new QPoint(static_cast<QPoint>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->buttonDownScreenPos(static_cast<Qt::MouseButton>(button))).x(), static_cast<QPoint>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->buttonDownScreenPos(static_cast<Qt::MouseButton>(button))).y());
}
int QGraphicsSceneMouseEvent_Buttons(void* ptr)
{
return static_cast<QGraphicsSceneMouseEvent*>(ptr)->buttons();
}
int QGraphicsSceneMouseEvent_Flags(void* ptr)
{
return static_cast<QGraphicsSceneMouseEvent*>(ptr)->flags();
}
void* QGraphicsSceneMouseEvent_LastPos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->lastPos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->lastPos()).y());
}
void* QGraphicsSceneMouseEvent_LastScenePos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->lastScenePos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->lastScenePos()).y());
}
void* QGraphicsSceneMouseEvent_LastScreenPos(void* ptr)
{
return new QPoint(static_cast<QPoint>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->lastScreenPos()).x(), static_cast<QPoint>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->lastScreenPos()).y());
}
int QGraphicsSceneMouseEvent_Modifiers(void* ptr)
{
return static_cast<QGraphicsSceneMouseEvent*>(ptr)->modifiers();
}
void* QGraphicsSceneMouseEvent_Pos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->pos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->pos()).y());
}
void* QGraphicsSceneMouseEvent_ScenePos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->scenePos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->scenePos()).y());
}
void* QGraphicsSceneMouseEvent_ScreenPos(void* ptr)
{
return new QPoint(static_cast<QPoint>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->screenPos()).x(), static_cast<QPoint>(static_cast<QGraphicsSceneMouseEvent*>(ptr)->screenPos()).y());
}
int 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 new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneMoveEvent*>(ptr)->newPos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneMoveEvent*>(ptr)->newPos()).y());
}
void* QGraphicsSceneMoveEvent_OldPos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneMoveEvent*>(ptr)->oldPos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneMoveEvent*>(ptr)->oldPos()).y());
}
void QGraphicsSceneMoveEvent_DestroyQGraphicsSceneMoveEvent(void* ptr)
{
static_cast<QGraphicsSceneMoveEvent*>(ptr)->~QGraphicsSceneMoveEvent();
}
void* QGraphicsSceneResizeEvent_NewQGraphicsSceneResizeEvent()
{
return new QGraphicsSceneResizeEvent();
}
void* QGraphicsSceneResizeEvent_NewSize(void* ptr)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsSceneResizeEvent*>(ptr)->newSize()).width(), static_cast<QSizeF>(static_cast<QGraphicsSceneResizeEvent*>(ptr)->newSize()).height());
}
void* QGraphicsSceneResizeEvent_OldSize(void* ptr)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsSceneResizeEvent*>(ptr)->oldSize()).width(), static_cast<QSizeF>(static_cast<QGraphicsSceneResizeEvent*>(ptr)->oldSize()).height());
}
void QGraphicsSceneResizeEvent_DestroyQGraphicsSceneResizeEvent(void* ptr)
{
static_cast<QGraphicsSceneResizeEvent*>(ptr)->~QGraphicsSceneResizeEvent();
}
int QGraphicsSceneWheelEvent_Buttons(void* ptr)
{
return static_cast<QGraphicsSceneWheelEvent*>(ptr)->buttons();
}
int QGraphicsSceneWheelEvent_Delta(void* ptr)
{
return static_cast<QGraphicsSceneWheelEvent*>(ptr)->delta();
}
int QGraphicsSceneWheelEvent_Modifiers(void* ptr)
{
return static_cast<QGraphicsSceneWheelEvent*>(ptr)->modifiers();
}
int QGraphicsSceneWheelEvent_Orientation(void* ptr)
{
return static_cast<QGraphicsSceneWheelEvent*>(ptr)->orientation();
}
void* QGraphicsSceneWheelEvent_Pos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneWheelEvent*>(ptr)->pos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneWheelEvent*>(ptr)->pos()).y());
}
void* QGraphicsSceneWheelEvent_ScenePos(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsSceneWheelEvent*>(ptr)->scenePos()).x(), static_cast<QPointF>(static_cast<QGraphicsSceneWheelEvent*>(ptr)->scenePos()).y());
}
void* QGraphicsSceneWheelEvent_ScreenPos(void* ptr)
{
return new QPoint(static_cast<QPoint>(static_cast<QGraphicsSceneWheelEvent*>(ptr)->screenPos()).x(), static_cast<QPoint>(static_cast<QGraphicsSceneWheelEvent*>(ptr)->screenPos()).y());
}
void QGraphicsSceneWheelEvent_DestroyQGraphicsSceneWheelEvent(void* ptr)
{
static_cast<QGraphicsSceneWheelEvent*>(ptr)->~QGraphicsSceneWheelEvent();
}
class MyQGraphicsSimpleTextItem: public QGraphicsSimpleTextItem
{
public:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
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), this->objectNameAbs().toUtf8().data())); };
bool contains(const QPointF & point) const { return callbackQGraphicsSimpleTextItem_Contains(const_cast<MyQGraphicsSimpleTextItem*>(this), this->objectNameAbs().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsSimpleTextItem_IsObscuredBy(const_cast<MyQGraphicsSimpleTextItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsSimpleTextItem_OpaqueArea(const_cast<MyQGraphicsSimpleTextItem*>(this), this->objectNameAbs().toUtf8().data())); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsSimpleTextItem_Paint(this, this->objectNameAbs().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsSimpleTextItem_Shape(const_cast<MyQGraphicsSimpleTextItem*>(this), this->objectNameAbs().toUtf8().data())); };
int type() const { return callbackQGraphicsSimpleTextItem_Type(const_cast<MyQGraphicsSimpleTextItem*>(this), this->objectNameAbs().toUtf8().data()); };
void advance(int phase) { callbackQGraphicsSimpleTextItem_Advance(this, this->objectNameAbs().toUtf8().data(), phase); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsSimpleTextItem_CollidesWithItem(const_cast<MyQGraphicsSimpleTextItem*>(this), this->objectNameAbs().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsSimpleTextItem_CollidesWithPath(const_cast<MyQGraphicsSimpleTextItem*>(this), this->objectNameAbs().toUtf8().data(), new QPainterPath(path), mode) != 0; };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsSimpleTextItem_ContextMenuEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsSimpleTextItem_DragEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsSimpleTextItem_DragLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsSimpleTextItem_DragMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsSimpleTextItem_DropEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsSimpleTextItem_FocusInEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsSimpleTextItem_FocusOutEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsSimpleTextItem_HoverEnterEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsSimpleTextItem_HoverLeaveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsSimpleTextItem_HoverMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsSimpleTextItem_InputMethodEvent(this, this->objectNameAbs().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsSimpleTextItem_InputMethodQuery(const_cast<MyQGraphicsSimpleTextItem*>(this), this->objectNameAbs().toUtf8().data(), query)); };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsSimpleTextItem_ItemChange(this, this->objectNameAbs().toUtf8().data(), change, new QVariant(value))); };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsSimpleTextItem_KeyPressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsSimpleTextItem_KeyReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsSimpleTextItem_MouseDoubleClickEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsSimpleTextItem_MouseMoveEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsSimpleTextItem_MousePressEvent(this, this->objectNameAbs().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsSimpleTextItem_MouseReleaseEvent(this, this->objectNameAbs().toUtf8().data(), event); };
bool sceneEvent(QEvent * event) { return callbackQGraphicsSimpleTextItem_SceneEvent(this, this->objectNameAbs().toUtf8().data(), event) != 0; };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsSimpleTextItem_SceneEventFilter(this, this->objectNameAbs().toUtf8().data(), watched, event) != 0; };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsSimpleTextItem_WheelEvent(this, this->objectNameAbs().toUtf8().data(), 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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsSimpleTextItem*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsSimpleTextItem*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsSimpleTextItem*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsSimpleTextItem*>(ptr)->boundingRect()).height());
}
void* QGraphicsSimpleTextItem_BoundingRectDefault(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::boundingRect()).height());
}
int QGraphicsSimpleTextItem_Contains(void* ptr, void* point)
{
return static_cast<QGraphicsSimpleTextItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int 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());
}
int QGraphicsSimpleTextItem_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QGraphicsSimpleTextItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int 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 static_cast<QGraphicsSimpleTextItem*>(ptr)->text().toUtf8().data();
}
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();
}
char* QGraphicsSimpleTextItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQGraphicsSimpleTextItem*>(static_cast<QGraphicsSimpleTextItem*>(ptr))) {
return static_cast<MyQGraphicsSimpleTextItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QGraphicsSimpleTextItem_BASE").toUtf8().data();
}
void QGraphicsSimpleTextItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQGraphicsSimpleTextItem*>(static_cast<QGraphicsSimpleTextItem*>(ptr))) {
static_cast<MyQGraphicsSimpleTextItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
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);
}
int QGraphicsSimpleTextItem_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsSimpleTextItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsSimpleTextItem_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsSimpleTextItem_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsSimpleTextItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsSimpleTextItem_CollidesWithPathDefault(void* ptr, void* path, int 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, int query)
{
return new QVariant(static_cast<QGraphicsSimpleTextItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsSimpleTextItem_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsSimpleTextItem_ItemChange(void* ptr, int 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, int 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));
}
int QGraphicsSimpleTextItem_SceneEvent(void* ptr, void* event)
{
return static_cast<QGraphicsSimpleTextItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsSimpleTextItem_SceneEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsSimpleTextItem*>(ptr)->QGraphicsSimpleTextItem::sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsSimpleTextItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsSimpleTextItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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), this->objectName().toUtf8().data())); };
bool contains(const QPointF & point) const { return callbackQGraphicsTextItem_Contains(const_cast<MyQGraphicsTextItem*>(this), this->objectName().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsTextItem_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsTextItem_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsTextItem_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsTextItem_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsTextItem_DropEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsTextItem_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsTextItem_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsTextItem_HoverEnterEvent(this, this->objectName().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsTextItem_HoverLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsTextItem_HoverMoveEvent(this, this->objectName().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsTextItem_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsTextItem_InputMethodQuery(const_cast<MyQGraphicsTextItem*>(this), this->objectName().toUtf8().data(), query)); };
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsTextItem_IsObscuredBy(const_cast<MyQGraphicsTextItem*>(this), this->objectName().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsTextItem_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsTextItem_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_LinkActivated(const QString & link) { callbackQGraphicsTextItem_LinkActivated(this, this->objectName().toUtf8().data(), link.toUtf8().data()); };
void Signal_LinkHovered(const QString & link) { callbackQGraphicsTextItem_LinkHovered(this, this->objectName().toUtf8().data(), link.toUtf8().data()); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsTextItem_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsTextItem_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsTextItem_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsTextItem_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsTextItem_OpaqueArea(const_cast<MyQGraphicsTextItem*>(this), this->objectName().toUtf8().data())); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsTextItem_Paint(this, this->objectName().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
bool sceneEvent(QEvent * event) { return callbackQGraphicsTextItem_SceneEvent(this, this->objectName().toUtf8().data(), event) != 0; };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsTextItem_Shape(const_cast<MyQGraphicsTextItem*>(this), this->objectName().toUtf8().data())); };
int type() const { return callbackQGraphicsTextItem_Type(const_cast<MyQGraphicsTextItem*>(this), this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQGraphicsTextItem_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsTextItem_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsTextItem_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsTextItem_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsTextItem_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsTextItem_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsTextItem_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsTextItem_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsTextItem_MetaObject(const_cast<MyQGraphicsTextItem*>(this), this->objectName().toUtf8().data())); };
void advance(int phase) { callbackQGraphicsTextItem_Advance(this, this->objectName().toUtf8().data(), phase); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsTextItem_CollidesWithItem(const_cast<MyQGraphicsTextItem*>(this), this->objectName().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsTextItem_CollidesWithPath(const_cast<MyQGraphicsTextItem*>(this), this->objectName().toUtf8().data(), new QPainterPath(path), mode) != 0; };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsTextItem_ItemChange(this, this->objectName().toUtf8().data(), change, new QVariant(value))); };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsTextItem_SceneEventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsTextItem_WheelEvent(this, this->objectName().toUtf8().data(), event); };
};
int QGraphicsTextItem_OpenExternalLinks(void* ptr)
{
return static_cast<QGraphicsTextItem*>(ptr)->openExternalLinks();
}
void QGraphicsTextItem_SetOpenExternalLinks(void* ptr, int 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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsTextItem*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsTextItem*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsTextItem*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsTextItem*>(ptr)->boundingRect()).height());
}
void* QGraphicsTextItem_BoundingRectDefault(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::boundingRect()).height());
}
int QGraphicsTextItem_Contains(void* ptr, void* point)
{
return static_cast<QGraphicsTextItem*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int 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, int query)
{
return new QVariant(static_cast<QGraphicsTextItem*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsTextItem_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
int QGraphicsTextItem_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QGraphicsTextItem*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int 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));
}
int QGraphicsTextItem_SceneEvent(void* ptr, void* event)
{
return static_cast<QGraphicsTextItem*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int 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, int b)
{
static_cast<QGraphicsTextItem*>(ptr)->setTabChangesFocus(b != 0);
}
void QGraphicsTextItem_SetTextInteractionFlags(void* ptr, int flags)
{
static_cast<QGraphicsTextItem*>(ptr)->setTextInteractionFlags(static_cast<Qt::TextInteractionFlag>(flags));
}
void QGraphicsTextItem_SetTextWidth(void* ptr, double width)
{
static_cast<QGraphicsTextItem*>(ptr)->setTextWidth(static_cast<double>(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());
}
int QGraphicsTextItem_TabChangesFocus(void* ptr)
{
return static_cast<QGraphicsTextItem*>(ptr)->tabChangesFocus();
}
int QGraphicsTextItem_TextInteractionFlags(void* ptr)
{
return static_cast<QGraphicsTextItem*>(ptr)->textInteractionFlags();
}
double QGraphicsTextItem_TextWidth(void* ptr)
{
return static_cast<double>(static_cast<QGraphicsTextItem*>(ptr)->textWidth());
}
char* QGraphicsTextItem_ToHtml(void* ptr)
{
return static_cast<QGraphicsTextItem*>(ptr)->toHtml().toUtf8().data();
}
char* QGraphicsTextItem_ToPlainText(void* ptr)
{
return static_cast<QGraphicsTextItem*>(ptr)->toPlainText().toUtf8().data();
}
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));
}
int QGraphicsTextItem_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsTextItem*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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);
}
int QGraphicsTextItem_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsTextItem*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsTextItem_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsTextItem_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsTextItem*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsTextItem_CollidesWithPathDefault(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
void* QGraphicsTextItem_ItemChange(void* ptr, int 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, int change, void* value)
{
return new QVariant(static_cast<QGraphicsTextItem*>(ptr)->QGraphicsTextItem::itemChange(static_cast<QGraphicsItem::GraphicsItemChange>(change), *static_cast<QVariant*>(value)));
}
int QGraphicsTextItem_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsTextItem*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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), this->objectName().toUtf8().data(), matrix); };
void update() { callbackQGraphicsTransform_Update(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsTransform_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsTransform_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsTransform_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsTransform_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsTransform_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsTransform_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQGraphicsTransform_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsTransform_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsTransform_MetaObject(const_cast<MyQGraphicsTransform*>(this), this->objectName().toUtf8().data())); };
};
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));
}
int QGraphicsTransform_Event(void* ptr, void* e)
{
return static_cast<QGraphicsTransform*>(ptr)->event(static_cast<QEvent*>(e));
}
int QGraphicsTransform_EventDefault(void* ptr, void* e)
{
return static_cast<QGraphicsTransform*>(ptr)->QGraphicsTransform::event(static_cast<QEvent*>(e));
}
int QGraphicsTransform_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsTransform*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQGraphicsView_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQGraphicsView_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQGraphicsView_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void drawBackground(QPainter * painter, const QRectF & rect) { callbackQGraphicsView_DrawBackground(this, this->objectName().toUtf8().data(), painter, new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height())); };
void drawForeground(QPainter * painter, const QRectF & rect) { callbackQGraphicsView_DrawForeground(this, this->objectName().toUtf8().data(), painter, new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height())); };
void dropEvent(QDropEvent * event) { callbackQGraphicsView_DropEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsView_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQGraphicsView_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsView_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsView_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsView_InputMethodQuery(const_cast<MyQGraphicsView*>(this), this->objectName().toUtf8().data(), query)); };
void invalidateScene(const QRectF & rect, QGraphicsScene::SceneLayers layers) { callbackQGraphicsView_InvalidateScene(this, this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height()), layers); };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsView_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsView_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQGraphicsView_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQGraphicsView_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQGraphicsView_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQGraphicsView_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQGraphicsView_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void resizeEvent(QResizeEvent * event) { callbackQGraphicsView_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_RubberBandChanged(QRect rubberBandRect, QPointF fromScenePoint, QPointF toScenePoint) { callbackQGraphicsView_RubberBandChanged(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rubberBandRect).x(), static_cast<QRect>(rubberBandRect).y(), static_cast<QRect>(rubberBandRect).width(), static_cast<QRect>(rubberBandRect).height()), new QPointF(static_cast<QPointF>(fromScenePoint).x(), static_cast<QPointF>(fromScenePoint).y()), new QPointF(static_cast<QPointF>(toScenePoint).x(), static_cast<QPointF>(toScenePoint).y())); };
void scrollContentsBy(int dx, int dy) { callbackQGraphicsView_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void setupViewport(QWidget * widget) { callbackQGraphicsView_SetupViewport(this, this->objectName().toUtf8().data(), widget); };
void showEvent(QShowEvent * event) { callbackQGraphicsView_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQGraphicsView_SizeHint(const_cast<MyQGraphicsView*>(this), this->objectName().toUtf8().data())); };
void updateSceneRect(const QRectF & rect) { callbackQGraphicsView_UpdateSceneRect(this, this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height())); };
bool viewportEvent(QEvent * event) { return callbackQGraphicsView_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
void wheelEvent(QWheelEvent * event) { callbackQGraphicsView_WheelEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQGraphicsView_MinimumSizeHint(const_cast<MyQGraphicsView*>(this), this->objectName().toUtf8().data())); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQGraphicsView_ViewportSizeHint(const_cast<MyQGraphicsView*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * ev) { callbackQGraphicsView_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQGraphicsView_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQGraphicsView_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQGraphicsView_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQGraphicsView_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQGraphicsView_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQGraphicsView_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQGraphicsView_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQGraphicsView_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQGraphicsView_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQGraphicsView_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQGraphicsView_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQGraphicsView_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQGraphicsView_HasHeightForWidth(const_cast<MyQGraphicsView*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQGraphicsView_HeightForWidth(const_cast<MyQGraphicsView*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQGraphicsView_Hide(this, this->objectName().toUtf8().data()); };
void lower() { callbackQGraphicsView_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQGraphicsView_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQGraphicsView_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQGraphicsView_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQGraphicsView_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQGraphicsView_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQGraphicsView_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQGraphicsView_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQGraphicsView_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQGraphicsView_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQGraphicsView_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQGraphicsView_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQGraphicsView_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQGraphicsView_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQGraphicsView_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsView_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsView_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsView_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsView_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsView_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsView_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsView_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsView_MetaObject(const_cast<MyQGraphicsView*>(this), this->objectName().toUtf8().data())); };
};
int QGraphicsView_Alignment(void* ptr)
{
return static_cast<QGraphicsView*>(ptr)->alignment();
}
void* QGraphicsView_BackgroundBrush(void* ptr)
{
return new QBrush(static_cast<QGraphicsView*>(ptr)->backgroundBrush());
}
int QGraphicsView_CacheMode(void* ptr)
{
return static_cast<QGraphicsView*>(ptr)->cacheMode();
}
int QGraphicsView_DragMode(void* ptr)
{
return static_cast<QGraphicsView*>(ptr)->dragMode();
}
void* QGraphicsView_ForegroundBrush(void* ptr)
{
return new QBrush(static_cast<QGraphicsView*>(ptr)->foregroundBrush());
}
int QGraphicsView_IsInteractive(void* ptr)
{
return static_cast<QGraphicsView*>(ptr)->isInteractive();
}
int QGraphicsView_OptimizationFlags(void* ptr)
{
return static_cast<QGraphicsView*>(ptr)->optimizationFlags();
}
int QGraphicsView_RenderHints(void* ptr)
{
return static_cast<QGraphicsView*>(ptr)->renderHints();
}
int QGraphicsView_ResizeAnchor(void* ptr)
{
return static_cast<QGraphicsView*>(ptr)->resizeAnchor();
}
int QGraphicsView_RubberBandSelectionMode(void* ptr)
{
return static_cast<QGraphicsView*>(ptr)->rubberBandSelectionMode();
}
void* QGraphicsView_SceneRect(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsView*>(ptr)->sceneRect()).x(), static_cast<QRectF>(static_cast<QGraphicsView*>(ptr)->sceneRect()).y(), static_cast<QRectF>(static_cast<QGraphicsView*>(ptr)->sceneRect()).width(), static_cast<QRectF>(static_cast<QGraphicsView*>(ptr)->sceneRect()).height());
}
void QGraphicsView_SetAlignment(void* ptr, int 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, int mode)
{
static_cast<QGraphicsView*>(ptr)->setCacheMode(static_cast<QGraphicsView::CacheModeFlag>(mode));
}
void QGraphicsView_SetDragMode(void* ptr, int 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, int allowed)
{
static_cast<QGraphicsView*>(ptr)->setInteractive(allowed != 0);
}
void QGraphicsView_SetOptimizationFlags(void* ptr, int flags)
{
static_cast<QGraphicsView*>(ptr)->setOptimizationFlags(static_cast<QGraphicsView::OptimizationFlag>(flags));
}
void QGraphicsView_SetRenderHints(void* ptr, int hints)
{
static_cast<QGraphicsView*>(ptr)->setRenderHints(static_cast<QPainter::RenderHint>(hints));
}
void QGraphicsView_SetResizeAnchor(void* ptr, int anchor)
{
static_cast<QGraphicsView*>(ptr)->setResizeAnchor(static_cast<QGraphicsView::ViewportAnchor>(anchor));
}
void QGraphicsView_SetRubberBandSelectionMode(void* ptr, int 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, int anchor)
{
static_cast<QGraphicsView*>(ptr)->setTransformationAnchor(static_cast<QGraphicsView::ViewportAnchor>(anchor));
}
void QGraphicsView_SetViewportUpdateMode(void* ptr, int mode)
{
static_cast<QGraphicsView*>(ptr)->setViewportUpdateMode(static_cast<QGraphicsView::ViewportUpdateMode>(mode));
}
int QGraphicsView_TransformationAnchor(void* ptr)
{
return static_cast<QGraphicsView*>(ptr)->transformationAnchor();
}
int 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(static_cast<double>(x), static_cast<double>(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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h), xmargin, ymargin);
}
int QGraphicsView_Event(void* ptr, void* event)
{
return static_cast<QGraphicsView*>(ptr)->event(static_cast<QEvent*>(event));
}
void QGraphicsView_FitInView3(void* ptr, void* item, int aspectRatioMode)
{
static_cast<QGraphicsView*>(ptr)->fitInView(static_cast<QGraphicsItem*>(item), static_cast<Qt::AspectRatioMode>(aspectRatioMode));
}
void QGraphicsView_FitInView(void* ptr, void* rect, int 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, int aspectRatioMode)
{
static_cast<QGraphicsView*>(ptr)->fitInView(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(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));
}
int QGraphicsView_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QGraphicsView*>(ptr)->focusNextPrevChild(next != 0);
}
int QGraphicsView_FocusNextPrevChildDefault(void* ptr, int 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, int query)
{
return new QVariant(static_cast<QGraphicsView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsView_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsView*>(ptr)->QGraphicsView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void QGraphicsView_InvalidateScene(void* ptr, void* rect, int layers)
{
QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "invalidateScene", Q_ARG(QRectF, *static_cast<QRectF*>(rect)), Q_ARG(QGraphicsScene::SceneLayer, static_cast<QGraphicsScene::SceneLayer>(layers)));
}
int 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 new QPoint(static_cast<QPoint>(static_cast<QGraphicsView*>(ptr)->mapFromScene(*static_cast<QPointF*>(point))).x(), static_cast<QPoint>(static_cast<QGraphicsView*>(ptr)->mapFromScene(*static_cast<QPointF*>(point))).y());
}
void* QGraphicsView_MapFromScene5(void* ptr, double x, double y)
{
return new QPoint(static_cast<QPoint>(static_cast<QGraphicsView*>(ptr)->mapFromScene(static_cast<double>(x), static_cast<double>(y))).x(), static_cast<QPoint>(static_cast<QGraphicsView*>(ptr)->mapFromScene(static_cast<double>(x), static_cast<double>(y))).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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(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 new QPointF(static_cast<QPointF>(static_cast<QGraphicsView*>(ptr)->mapToScene(*static_cast<QPoint*>(point))).x(), static_cast<QPointF>(static_cast<QGraphicsView*>(ptr)->mapToScene(*static_cast<QPoint*>(point))).y());
}
void* QGraphicsView_MapToScene5(void* ptr, int x, int y)
{
return new QPointF(static_cast<QPointF>(static_cast<QGraphicsView*>(ptr)->mapToScene(x, y)).x(), static_cast<QPointF>(static_cast<QGraphicsView*>(ptr)->mapToScene(x, y)).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, int 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(static_cast<double>(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 new QRect(static_cast<QRect>(static_cast<QGraphicsView*>(ptr)->rubberBandRect()).x(), static_cast<QRect>(static_cast<QGraphicsView*>(ptr)->rubberBandRect()).y(), static_cast<QRect>(static_cast<QGraphicsView*>(ptr)->rubberBandRect()).width(), static_cast<QRect>(static_cast<QGraphicsView*>(ptr)->rubberBandRect()).height());
}
void QGraphicsView_Scale(void* ptr, double sx, double sy)
{
static_cast<QGraphicsView*>(ptr)->scale(static_cast<double>(sx), static_cast<double>(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, int flag, int enabled)
{
static_cast<QGraphicsView*>(ptr)->setOptimizationFlag(static_cast<QGraphicsView::OptimizationFlag>(flag), enabled != 0);
}
void QGraphicsView_SetRenderHint(void* ptr, int hint, int 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(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h));
}
void QGraphicsView_SetTransform(void* ptr, void* matrix, int 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(static_cast<double>(sh), static_cast<double>(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 new QSize(static_cast<QSize>(static_cast<QGraphicsView*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QGraphicsView*>(ptr)->sizeHint()).height());
}
void* QGraphicsView_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QGraphicsView*>(ptr)->QGraphicsView::sizeHint()).width(), static_cast<QSize>(static_cast<QGraphicsView*>(ptr)->QGraphicsView::sizeHint()).height());
}
void QGraphicsView_Translate(void* ptr, double dx, double dy)
{
static_cast<QGraphicsView*>(ptr)->translate(static_cast<double>(dx), static_cast<double>(dy));
}
void QGraphicsView_UpdateSceneRect(void* ptr, void* rect)
{
QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "updateSceneRect", Q_ARG(QRectF, *static_cast<QRectF*>(rect)));
}
int QGraphicsView_ViewportEvent(void* ptr, void* event)
{
return static_cast<QGraphicsView*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int QGraphicsView_ViewportEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsView*>(ptr)->QGraphicsView::viewportEvent(static_cast<QEvent*>(event));
}
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 new QSize(static_cast<QSize>(static_cast<QGraphicsView*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QGraphicsView*>(ptr)->minimumSizeHint()).height());
}
void* QGraphicsView_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QGraphicsView*>(ptr)->QGraphicsView::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QGraphicsView*>(ptr)->QGraphicsView::minimumSizeHint()).height());
}
void* QGraphicsView_ViewportSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QGraphicsView*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QGraphicsView*>(ptr)->viewportSizeHint()).height());
}
void* QGraphicsView_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QGraphicsView*>(ptr)->QGraphicsView::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QGraphicsView*>(ptr)->QGraphicsView::viewportSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QGraphicsView_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QGraphicsView_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QGraphicsView*>(ptr)->QGraphicsView::setVisible(visible != 0);
}
void QGraphicsView_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QGraphicsView_SetWindowModifiedDefault(void* ptr, int 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));
}
int QGraphicsView_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QGraphicsView_HasHeightForWidth(void* ptr)
{
return static_cast<QGraphicsView*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QGraphicsView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QGraphicsView*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QGraphicsView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QGraphicsView*>(ptr)->QGraphicsView::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QGraphicsView_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QGraphicsView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QGraphicsView_SetHiddenDefault(void* ptr, int 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));
}
int QGraphicsView_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height())); };
QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsWidget_BoundingRect(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * event) { callbackQGraphicsWidget_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQGraphicsWidget_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQGraphicsWidget_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQGraphicsWidget_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQGraphicsWidget_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * event) { callbackQGraphicsWidget_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_GeometryChanged() { callbackQGraphicsWidget_GeometryChanged(this, this->objectName().toUtf8().data()); };
void getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom) const { callbackQGraphicsWidget_GetContentsMargins(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data(), *static_cast<double*>(left), *static_cast<double*>(top), *static_cast<double*>(right), *static_cast<double*>(bottom)); };
void grabKeyboardEvent(QEvent * event) { callbackQGraphicsWidget_GrabKeyboardEvent(this, this->objectName().toUtf8().data(), event); };
void grabMouseEvent(QEvent * event) { callbackQGraphicsWidget_GrabMouseEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQGraphicsWidget_HideEvent(this, this->objectName().toUtf8().data(), event); };
void hoverLeaveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsWidget_HoverLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void hoverMoveEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsWidget_HoverMoveEvent(this, this->objectName().toUtf8().data(), event); };
void initStyleOption(QStyleOption * option) const { callbackQGraphicsWidget_InitStyleOption(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data(), option); };
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQGraphicsWidget_ItemChange(this, this->objectName().toUtf8().data(), change, new QVariant(value))); };
void moveEvent(QGraphicsSceneMoveEvent * event) { callbackQGraphicsWidget_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsWidget_Paint(this, this->objectName().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
void paintWindowFrame(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsWidget_PaintWindowFrame(this, this->objectName().toUtf8().data(), painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
void polishEvent() { callbackQGraphicsWidget_PolishEvent(this, this->objectName().toUtf8().data()); };
void resizeEvent(QGraphicsSceneResizeEvent * event) { callbackQGraphicsWidget_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
bool sceneEvent(QEvent * event) { return callbackQGraphicsWidget_SceneEvent(this, this->objectName().toUtf8().data(), event) != 0; };
QPainterPath shape() const { return *static_cast<QPainterPath*>(callbackQGraphicsWidget_Shape(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data())); };
void showEvent(QShowEvent * event) { callbackQGraphicsWidget_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint) const { return *static_cast<QSizeF*>(callbackQGraphicsWidget_SizeHint(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data(), which, new QSizeF(static_cast<QSizeF>(constraint).width(), static_cast<QSizeF>(constraint).height()))); };
int type() const { return callbackQGraphicsWidget_Type(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data()); };
void ungrabKeyboardEvent(QEvent * event) { callbackQGraphicsWidget_UngrabKeyboardEvent(this, this->objectName().toUtf8().data(), event); };
void ungrabMouseEvent(QEvent * event) { callbackQGraphicsWidget_UngrabMouseEvent(this, this->objectName().toUtf8().data(), event); };
void updateGeometry() { callbackQGraphicsWidget_UpdateGeometry(this, this->objectName().toUtf8().data()); };
bool windowFrameEvent(QEvent * event) { return callbackQGraphicsWidget_WindowFrameEvent(this, this->objectName().toUtf8().data(), event) != 0; };
Qt::WindowFrameSection windowFrameSectionAt(const QPointF & pos) const { return static_cast<Qt::WindowFrameSection>(callbackQGraphicsWidget_WindowFrameSectionAt(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data(), new QPointF(static_cast<QPointF>(pos).x(), static_cast<QPointF>(pos).y()))); };
void updateMicroFocus() { callbackQGraphicsWidget_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQGraphicsWidget_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQGraphicsWidget_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGraphicsWidget_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGraphicsWidget_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGraphicsWidget_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsWidget_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsWidget_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsWidget_MetaObject(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data())); };
void advance(int phase) { callbackQGraphicsWidget_Advance(this, this->objectName().toUtf8().data(), phase); };
bool collidesWithItem(const QGraphicsItem * other, Qt::ItemSelectionMode mode) const { return callbackQGraphicsWidget_CollidesWithItem(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data(), const_cast<QGraphicsItem*>(other), mode) != 0; };
bool collidesWithPath(const QPainterPath & path, Qt::ItemSelectionMode mode) const { return callbackQGraphicsWidget_CollidesWithPath(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data(), new QPainterPath(path), mode) != 0; };
bool contains(const QPointF & point) const { return callbackQGraphicsWidget_Contains(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data(), new QPointF(static_cast<QPointF>(point).x(), static_cast<QPointF>(point).y())) != 0; };
void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) { callbackQGraphicsWidget_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsWidget_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsWidget_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsWidget_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QGraphicsSceneDragDropEvent * event) { callbackQGraphicsWidget_DropEvent(this, this->objectName().toUtf8().data(), event); };
void hoverEnterEvent(QGraphicsSceneHoverEvent * event) { callbackQGraphicsWidget_HoverEnterEvent(this, this->objectName().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGraphicsWidget_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGraphicsWidget_InputMethodQuery(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data(), query)); };
bool isObscuredBy(const QGraphicsItem * item) const { return callbackQGraphicsWidget_IsObscuredBy(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data(), const_cast<QGraphicsItem*>(item)) != 0; };
void keyPressEvent(QKeyEvent * event) { callbackQGraphicsWidget_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGraphicsWidget_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsWidget_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsWidget_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsWidget_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QGraphicsSceneMouseEvent * event) { callbackQGraphicsWidget_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
QPainterPath opaqueArea() const { return *static_cast<QPainterPath*>(callbackQGraphicsWidget_OpaqueArea(const_cast<MyQGraphicsWidget*>(this), this->objectName().toUtf8().data())); };
bool sceneEventFilter(QGraphicsItem * watched, QEvent * event) { return callbackQGraphicsWidget_SceneEventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
void wheelEvent(QGraphicsSceneWheelEvent * event) { callbackQGraphicsWidget_WheelEvent(this, this->objectName().toUtf8().data(), event); };
};
int QGraphicsWidget_AutoFillBackground(void* ptr)
{
return static_cast<QGraphicsWidget*>(ptr)->autoFillBackground();
}
int QGraphicsWidget_FocusPolicy(void* ptr)
{
return static_cast<QGraphicsWidget*>(ptr)->focusPolicy();
}
void* QGraphicsWidget_Font(void* ptr)
{
return new QFont(static_cast<QGraphicsWidget*>(ptr)->font());
}
int 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, int enabled)
{
static_cast<QGraphicsWidget*>(ptr)->setAutoFillBackground(enabled != 0);
}
void QGraphicsWidget_SetFocusPolicy(void* ptr, int 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, int 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, int 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 new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsWidget*>(ptr)->size()).width(), static_cast<QSizeF>(static_cast<QGraphicsWidget*>(ptr)->size()).height());
}
void QGraphicsWidget_UnsetLayoutDirection(void* ptr)
{
static_cast<QGraphicsWidget*>(ptr)->unsetLayoutDirection();
}
int QGraphicsWidget_WindowFlags(void* ptr)
{
return static_cast<QGraphicsWidget*>(ptr)->windowFlags();
}
char* QGraphicsWidget_WindowTitle(void* ptr)
{
return static_cast<QGraphicsWidget*>(ptr)->windowTitle().toUtf8().data();
}
void* QGraphicsWidget_NewQGraphicsWidget(void* parent, int 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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->boundingRect()).height());
}
void* QGraphicsWidget_BoundingRectDefault(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::boundingRect()).x(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::boundingRect()).y(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::boundingRect()).width(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::boundingRect()).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));
}
int 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));
}
int 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));
}
int QGraphicsWidget_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QGraphicsWidget*>(ptr)->focusNextPrevChild(next != 0);
}
int QGraphicsWidget_FocusNextPrevChildDefault(void* ptr, int 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_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, int 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));
}
int QGraphicsWidget_IsActiveWindow(void* ptr)
{
return static_cast<QGraphicsWidget*>(ptr)->isActiveWindow();
}
void* QGraphicsWidget_ItemChange(void* ptr, int 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, int 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 new QRectF(static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->rect()).x(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->rect()).y(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->rect()).width(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->rect()).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(static_cast<double>(w), static_cast<double>(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));
}
int QGraphicsWidget_SceneEvent(void* ptr, void* event)
{
return static_cast<QGraphicsWidget*>(ptr)->sceneEvent(static_cast<QEvent*>(event));
}
int QGraphicsWidget_SceneEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::sceneEvent(static_cast<QEvent*>(event));
}
void QGraphicsWidget_SetAttribute(void* ptr, int attribute, int 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(static_cast<double>(left), static_cast<double>(top), static_cast<double>(right), static_cast<double>(bottom));
}
void QGraphicsWidget_SetGeometry2(void* ptr, double x, double y, double w, double h)
{
static_cast<QGraphicsWidget*>(ptr)->setGeometry(static_cast<double>(x), static_cast<double>(y), static_cast<double>(w), static_cast<double>(h));
}
void QGraphicsWidget_SetShortcutAutoRepeat(void* ptr, int id, int enabled)
{
static_cast<QGraphicsWidget*>(ptr)->setShortcutAutoRepeat(id, enabled != 0);
}
void QGraphicsWidget_SetShortcutEnabled(void* ptr, int id, int 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(static_cast<double>(left), static_cast<double>(top), static_cast<double>(right), static_cast<double>(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, int which, void* constraint)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsWidget*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).width(), static_cast<QSizeF>(static_cast<QGraphicsWidget*>(ptr)->sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).height());
}
void* QGraphicsWidget_SizeHintDefault(void* ptr, int which, void* constraint)
{
return new QSizeF(static_cast<QSizeF>(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).width(), static_cast<QSizeF>(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::sizeHint(static_cast<Qt::SizeHint>(which), *static_cast<QSizeF*>(constraint))).height());
}
void* QGraphicsWidget_Style(void* ptr)
{
return static_cast<QGraphicsWidget*>(ptr)->style();
}
int QGraphicsWidget_TestAttribute(void* ptr, int 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();
}
int QGraphicsWidget_WindowFrameEvent(void* ptr, void* event)
{
return static_cast<QGraphicsWidget*>(ptr)->windowFrameEvent(static_cast<QEvent*>(event));
}
int QGraphicsWidget_WindowFrameEventDefault(void* ptr, void* event)
{
return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::windowFrameEvent(static_cast<QEvent*>(event));
}
void* QGraphicsWidget_WindowFrameGeometry(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->windowFrameGeometry()).x(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->windowFrameGeometry()).y(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->windowFrameGeometry()).width(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->windowFrameGeometry()).height());
}
void* QGraphicsWidget_WindowFrameRect(void* ptr)
{
return new QRectF(static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->windowFrameRect()).x(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->windowFrameRect()).y(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->windowFrameRect()).width(), static_cast<QRectF>(static_cast<QGraphicsWidget*>(ptr)->windowFrameRect()).height());
}
int QGraphicsWidget_WindowFrameSectionAt(void* ptr, void* pos)
{
return static_cast<QGraphicsWidget*>(ptr)->windowFrameSectionAt(*static_cast<QPointF*>(pos));
}
int QGraphicsWidget_WindowFrameSectionAtDefault(void* ptr, void* pos)
{
return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::windowFrameSectionAt(*static_cast<QPointF*>(pos));
}
int 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));
}
int QGraphicsWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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);
}
int QGraphicsWidget_CollidesWithItem(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsWidget*>(ptr)->collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsWidget_CollidesWithItemDefault(void* ptr, void* other, int mode)
{
return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::collidesWithItem(static_cast<QGraphicsItem*>(other), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsWidget_CollidesWithPath(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsWidget*>(ptr)->collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsWidget_CollidesWithPathDefault(void* ptr, void* path, int mode)
{
return static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::collidesWithPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ItemSelectionMode>(mode));
}
int QGraphicsWidget_Contains(void* ptr, void* point)
{
return static_cast<QGraphicsWidget*>(ptr)->contains(*static_cast<QPointF*>(point));
}
int 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, int query)
{
return new QVariant(static_cast<QGraphicsWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGraphicsWidget_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QGraphicsWidget*>(ptr)->QGraphicsWidget::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
int QGraphicsWidget_IsObscuredBy(void* ptr, void* item)
{
return static_cast<QGraphicsWidget*>(ptr)->isObscuredBy(static_cast<QGraphicsItem*>(item));
}
int 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());
}
int QGraphicsWidget_SceneEventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsWidget*>(ptr)->sceneEventFilter(static_cast<QGraphicsItem*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), item); };
int count() const { return callbackQGridLayout_Count(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data()); };
Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQGridLayout_ExpandingDirections(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data())); };
bool hasHeightForWidth() const { return callbackQGridLayout_HasHeightForWidth(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQGridLayout_HeightForWidth(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data(), w); };
void invalidate() { callbackQGridLayout_Invalidate(this, this->objectName().toUtf8().data()); };
QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQGridLayout_ItemAt(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data(), index)); };
QSize maximumSize() const { return *static_cast<QSize*>(callbackQGridLayout_MaximumSize(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data())); };
int minimumHeightForWidth(int w) const { return callbackQGridLayout_MinimumHeightForWidth(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data(), w); };
QSize minimumSize() const { return *static_cast<QSize*>(callbackQGridLayout_MinimumSize(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data())); };
void setGeometry(const QRect & rect) { callbackQGridLayout_SetGeometry(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height())); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQGridLayout_SizeHint(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data())); };
QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQGridLayout_TakeAt(this, this->objectName().toUtf8().data(), index)); };
QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQGridLayout_ControlTypes(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data())); };
QRect geometry() const { return *static_cast<QRect*>(callbackQGridLayout_Geometry(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data())); };
int indexOf(QWidget * widget) const { return callbackQGridLayout_IndexOf(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data(), widget); };
bool isEmpty() const { return callbackQGridLayout_IsEmpty(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data()) != 0; };
QLayout * layout() { return static_cast<QLayout*>(callbackQGridLayout_Layout(this, this->objectName().toUtf8().data())); };
void timerEvent(QTimerEvent * event) { callbackQGridLayout_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGridLayout_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGridLayout_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGridLayout_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGridLayout_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQGridLayout_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGridLayout_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGridLayout_MetaObject(const_cast<MyQGridLayout*>(this), this->objectName().toUtf8().data())); };
QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQGridLayout_SpacerItem(this, this->objectName().toUtf8().data())); };
QWidget * widget() { return static_cast<QWidget*>(callbackQGridLayout_Widget(this, this->objectName().toUtf8().data())); };
};
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, int 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, int 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, int 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, int 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, int 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 new QRect(static_cast<QRect>(static_cast<QGridLayout*>(ptr)->cellRect(row, column)).x(), static_cast<QRect>(static_cast<QGridLayout*>(ptr)->cellRect(row, column)).y(), static_cast<QRect>(static_cast<QGridLayout*>(ptr)->cellRect(row, column)).width(), static_cast<QRect>(static_cast<QGridLayout*>(ptr)->cellRect(row, column)).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();
}
int QGridLayout_ExpandingDirections(void* ptr)
{
return static_cast<QGridLayout*>(ptr)->expandingDirections();
}
int 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);
}
int QGridLayout_HasHeightForWidth(void* ptr)
{
return static_cast<QGridLayout*>(ptr)->hasHeightForWidth();
}
int 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 new QSize(static_cast<QSize>(static_cast<QGridLayout*>(ptr)->maximumSize()).width(), static_cast<QSize>(static_cast<QGridLayout*>(ptr)->maximumSize()).height());
}
void* QGridLayout_MaximumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QGridLayout*>(ptr)->QGridLayout::maximumSize()).width(), static_cast<QSize>(static_cast<QGridLayout*>(ptr)->QGridLayout::maximumSize()).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 new QSize(static_cast<QSize>(static_cast<QGridLayout*>(ptr)->minimumSize()).width(), static_cast<QSize>(static_cast<QGridLayout*>(ptr)->minimumSize()).height());
}
void* QGridLayout_MinimumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QGridLayout*>(ptr)->QGridLayout::minimumSize()).width(), static_cast<QSize>(static_cast<QGridLayout*>(ptr)->QGridLayout::minimumSize()).height());
}
int 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, int 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 new QSize(static_cast<QSize>(static_cast<QGridLayout*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QGridLayout*>(ptr)->sizeHint()).height());
}
void* QGridLayout_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QGridLayout*>(ptr)->QGridLayout::sizeHint()).width(), static_cast<QSize>(static_cast<QGridLayout*>(ptr)->QGridLayout::sizeHint()).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();
}
int QGridLayout_ControlTypes(void* ptr)
{
return static_cast<QGridLayout*>(ptr)->controlTypes();
}
int QGridLayout_ControlTypesDefault(void* ptr)
{
return static_cast<QGridLayout*>(ptr)->QGridLayout::controlTypes();
}
void* QGridLayout_Geometry(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QGridLayout*>(ptr)->geometry()).x(), static_cast<QRect>(static_cast<QGridLayout*>(ptr)->geometry()).y(), static_cast<QRect>(static_cast<QGridLayout*>(ptr)->geometry()).width(), static_cast<QRect>(static_cast<QGridLayout*>(ptr)->geometry()).height());
}
void* QGridLayout_GeometryDefault(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QGridLayout*>(ptr)->QGridLayout::geometry()).x(), static_cast<QRect>(static_cast<QGridLayout*>(ptr)->QGridLayout::geometry()).y(), static_cast<QRect>(static_cast<QGridLayout*>(ptr)->QGridLayout::geometry()).width(), static_cast<QRect>(static_cast<QGridLayout*>(ptr)->QGridLayout::geometry()).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));
}
int QGridLayout_IsEmpty(void* ptr)
{
return static_cast<QGridLayout*>(ptr)->isEmpty();
}
int 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));
}
int QGridLayout_Event(void* ptr, void* e)
{
return static_cast<QGridLayout*>(ptr)->event(static_cast<QEvent*>(e));
}
int QGridLayout_EventDefault(void* ptr, void* e)
{
return static_cast<QGridLayout*>(ptr)->QGridLayout::event(static_cast<QEvent*>(e));
}
int QGridLayout_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGridLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), checked); };
void changeEvent(QEvent * ev) { callbackQGroupBox_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void Signal_Clicked(bool checked) { callbackQGroupBox_Clicked(this, this->objectName().toUtf8().data(), checked); };
void focusInEvent(QFocusEvent * fe) { callbackQGroupBox_FocusInEvent(this, this->objectName().toUtf8().data(), fe); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQGroupBox_MinimumSizeHint(const_cast<MyQGroupBox*>(this), this->objectName().toUtf8().data())); };
void mouseMoveEvent(QMouseEvent * event) { callbackQGroupBox_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQGroupBox_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQGroupBox_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQGroupBox_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void resizeEvent(QResizeEvent * e) { callbackQGroupBox_ResizeEvent(this, this->objectName().toUtf8().data(), e); };
void Signal_Toggled(bool on) { callbackQGroupBox_Toggled(this, this->objectName().toUtf8().data(), on); };
void actionEvent(QActionEvent * event) { callbackQGroupBox_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQGroupBox_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQGroupBox_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQGroupBox_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQGroupBox_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQGroupBox_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQGroupBox_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQGroupBox_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQGroupBox_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQGroupBox_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQGroupBox_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQGroupBox_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQGroupBox_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQGroupBox_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQGroupBox_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQGroupBox_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQGroupBox_SizeHint(const_cast<MyQGroupBox*>(this), this->objectName().toUtf8().data())); };
bool close() { return callbackQGroupBox_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQGroupBox_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQGroupBox_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQGroupBox_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQGroupBox_HasHeightForWidth(const_cast<MyQGroupBox*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQGroupBox_HeightForWidth(const_cast<MyQGroupBox*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQGroupBox_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQGroupBox_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQGroupBox_InputMethodQuery(const_cast<MyQGroupBox*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQGroupBox_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQGroupBox_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQGroupBox_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQGroupBox_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQGroupBox_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQGroupBox_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQGroupBox_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQGroupBox_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQGroupBox_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQGroupBox_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQGroupBox_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQGroupBox_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQGroupBox_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQGroupBox_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQGroupBox_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQGroupBox_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQGroupBox_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQGroupBox_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQGroupBox_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQGroupBox_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQGroupBox_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQGroupBox_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQGroupBox_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGroupBox_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGroupBox_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGroupBox_MetaObject(const_cast<MyQGroupBox*>(this), this->objectName().toUtf8().data())); };
};
int QGroupBox_Alignment(void* ptr)
{
return static_cast<QGroupBox*>(ptr)->alignment();
}
int QGroupBox_IsCheckable(void* ptr)
{
return static_cast<QGroupBox*>(ptr)->isCheckable();
}
int QGroupBox_IsChecked(void* ptr)
{
return static_cast<QGroupBox*>(ptr)->isChecked();
}
int 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, int checkable)
{
static_cast<QGroupBox*>(ptr)->setCheckable(checkable != 0);
}
void QGroupBox_SetChecked(void* ptr, int checked)
{
QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setChecked", Q_ARG(bool, checked != 0));
}
void QGroupBox_SetFlat(void* ptr, int 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 static_cast<QGroupBox*>(ptr)->title().toUtf8().data();
}
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, int checked)
{
static_cast<QGroupBox*>(ptr)->clicked(checked != 0);
}
int 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 new QSize(static_cast<QSize>(static_cast<QGroupBox*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QGroupBox*>(ptr)->minimumSizeHint()).height());
}
void* QGroupBox_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QGroupBox*>(ptr)->QGroupBox::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QGroupBox*>(ptr)->QGroupBox::minimumSizeHint()).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, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QGroupBox_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QGroupBox_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QGroupBox*>(ptr)->QGroupBox::setVisible(visible != 0);
}
void QGroupBox_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QGroupBox_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QGroupBox*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QGroupBox*>(ptr)->sizeHint()).height());
}
void* QGroupBox_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QGroupBox*>(ptr)->QGroupBox::sizeHint()).width(), static_cast<QSize>(static_cast<QGroupBox*>(ptr)->QGroupBox::sizeHint()).height());
}
int QGroupBox_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QGroupBox_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QGroupBox*>(ptr)->focusNextPrevChild(next != 0);
}
int QGroupBox_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QGroupBox*>(ptr)->QGroupBox::focusNextPrevChild(next != 0);
}
int QGroupBox_HasHeightForWidth(void* ptr)
{
return static_cast<QGroupBox*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QGroupBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QGroupBox_InputMethodQueryDefault(void* ptr, int 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));
}
int QGroupBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QGroupBox*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QGroupBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QGroupBox*>(ptr)->QGroupBox::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QGroupBox_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QGroupBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QGroupBox_SetHiddenDefault(void* ptr, int 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));
}
int QGroupBox_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGroupBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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();
}
int QHBoxLayout_ExpandingDirections(void* ptr)
{
return static_cast<QHBoxLayout*>(ptr)->expandingDirections();
}
int QHBoxLayout_ExpandingDirectionsDefault(void* ptr)
{
return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::expandingDirections();
}
int QHBoxLayout_HasHeightForWidth(void* ptr)
{
return static_cast<QHBoxLayout*>(ptr)->hasHeightForWidth();
}
int 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 new QSize(static_cast<QSize>(static_cast<QHBoxLayout*>(ptr)->maximumSize()).width(), static_cast<QSize>(static_cast<QHBoxLayout*>(ptr)->maximumSize()).height());
}
void* QHBoxLayout_MaximumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::maximumSize()).width(), static_cast<QSize>(static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::maximumSize()).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 new QSize(static_cast<QSize>(static_cast<QHBoxLayout*>(ptr)->minimumSize()).width(), static_cast<QSize>(static_cast<QHBoxLayout*>(ptr)->minimumSize()).height());
}
void* QHBoxLayout_MinimumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::minimumSize()).width(), static_cast<QSize>(static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::minimumSize()).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 new QSize(static_cast<QSize>(static_cast<QHBoxLayout*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QHBoxLayout*>(ptr)->sizeHint()).height());
}
void* QHBoxLayout_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::sizeHint()).width(), static_cast<QSize>(static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::sizeHint()).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);
}
int QHBoxLayout_ControlTypes(void* ptr)
{
return static_cast<QHBoxLayout*>(ptr)->controlTypes();
}
int QHBoxLayout_ControlTypesDefault(void* ptr)
{
return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::controlTypes();
}
void* QHBoxLayout_Geometry(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QHBoxLayout*>(ptr)->geometry()).x(), static_cast<QRect>(static_cast<QHBoxLayout*>(ptr)->geometry()).y(), static_cast<QRect>(static_cast<QHBoxLayout*>(ptr)->geometry()).width(), static_cast<QRect>(static_cast<QHBoxLayout*>(ptr)->geometry()).height());
}
void* QHBoxLayout_GeometryDefault(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::geometry()).x(), static_cast<QRect>(static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::geometry()).y(), static_cast<QRect>(static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::geometry()).width(), static_cast<QRect>(static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::geometry()).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));
}
int QHBoxLayout_IsEmpty(void* ptr)
{
return static_cast<QHBoxLayout*>(ptr)->isEmpty();
}
int 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));
}
int QHBoxLayout_Event(void* ptr, void* e)
{
return static_cast<QHBoxLayout*>(ptr)->event(static_cast<QEvent*>(e));
}
int QHBoxLayout_EventDefault(void* ptr, void* e)
{
return static_cast<QHBoxLayout*>(ptr)->QHBoxLayout::event(static_cast<QEvent*>(e));
}
int QHBoxLayout_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QHBoxLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), offset); };
void currentChanged(const QModelIndex & current, const QModelIndex & old) { callbackQHeaderView_CurrentChanged(this, this->objectName().toUtf8().data(), new QModelIndex(current), new QModelIndex(old)); };
void Signal_GeometriesChanged() { callbackQHeaderView_GeometriesChanged(this, this->objectName().toUtf8().data()); };
void headerDataChanged(Qt::Orientation orientation, int logicalFirst, int logicalLast) { callbackQHeaderView_HeaderDataChanged(this, this->objectName().toUtf8().data(), orientation, logicalFirst, logicalLast); };
int horizontalOffset() const { return callbackQHeaderView_HorizontalOffset(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * e) { callbackQHeaderView_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), e); };
void mouseMoveEvent(QMouseEvent * e) { callbackQHeaderView_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQHeaderView_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQHeaderView_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void paintEvent(QPaintEvent * e) { callbackQHeaderView_PaintEvent(this, this->objectName().toUtf8().data(), e); };
void paintSection(QPainter * painter, const QRect & rect, int logicalIndex) const { callbackQHeaderView_PaintSection(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data(), painter, new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), logicalIndex); };
void reset() { callbackQHeaderView_Reset(this, this->objectName().toUtf8().data()); };
void resizeSections() { callbackQHeaderView_ResizeSections2(this, this->objectName().toUtf8().data()); };
void Signal_SectionClicked(int logicalIndex) { callbackQHeaderView_SectionClicked(this, this->objectName().toUtf8().data(), logicalIndex); };
void Signal_SectionCountChanged(int oldCount, int newCount) { callbackQHeaderView_SectionCountChanged(this, this->objectName().toUtf8().data(), oldCount, newCount); };
void Signal_SectionDoubleClicked(int logicalIndex) { callbackQHeaderView_SectionDoubleClicked(this, this->objectName().toUtf8().data(), logicalIndex); };
void Signal_SectionEntered(int logicalIndex) { callbackQHeaderView_SectionEntered(this, this->objectName().toUtf8().data(), logicalIndex); };
void Signal_SectionHandleDoubleClicked(int logicalIndex) { callbackQHeaderView_SectionHandleDoubleClicked(this, this->objectName().toUtf8().data(), logicalIndex); };
void Signal_SectionMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex) { callbackQHeaderView_SectionMoved(this, this->objectName().toUtf8().data(), logicalIndex, oldVisualIndex, newVisualIndex); };
void Signal_SectionPressed(int logicalIndex) { callbackQHeaderView_SectionPressed(this, this->objectName().toUtf8().data(), logicalIndex); };
void Signal_SectionResized(int logicalIndex, int oldSize, int newSize) { callbackQHeaderView_SectionResized(this, this->objectName().toUtf8().data(), logicalIndex, oldSize, newSize); };
QSize sectionSizeFromContents(int logicalIndex) const { return *static_cast<QSize*>(callbackQHeaderView_SectionSizeFromContents(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data(), logicalIndex)); };
void sectionsAboutToBeRemoved(const QModelIndex & parent, int logicalFirst, int logicalLast) { callbackQHeaderView_SectionsAboutToBeRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), logicalFirst, logicalLast); };
void sectionsInserted(const QModelIndex & parent, int logicalFirst, int logicalLast) { callbackQHeaderView_SectionsInserted(this, this->objectName().toUtf8().data(), new QModelIndex(parent), logicalFirst, logicalLast); };
void setModel(QAbstractItemModel * model) { callbackQHeaderView_SetModel(this, this->objectName().toUtf8().data(), model); };
void setOffsetToLastSection() { callbackQHeaderView_SetOffsetToLastSection(this, this->objectName().toUtf8().data()); };
void setOffsetToSectionPosition(int visualSectionNumber) { callbackQHeaderView_SetOffsetToSectionPosition(this, this->objectName().toUtf8().data(), visualSectionNumber); };
void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags flags) { callbackQHeaderView_SetSelection(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), flags); };
void setVisible(bool v) { callbackQHeaderView_SetVisible(this, this->objectName().toUtf8().data(), v); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQHeaderView_SizeHint(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data())); };
void Signal_SortIndicatorChanged(int logicalIndex, Qt::SortOrder order) { callbackQHeaderView_SortIndicatorChanged(this, this->objectName().toUtf8().data(), logicalIndex, order); };
int verticalOffset() const { return callbackQHeaderView_VerticalOffset(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data()); };
bool viewportEvent(QEvent * e) { return callbackQHeaderView_ViewportEvent(this, this->objectName().toUtf8().data(), e) != 0; };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQHeaderView_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void clearSelection() { callbackQHeaderView_ClearSelection(this, this->objectName().toUtf8().data()); };
void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQHeaderView_CloseEditor(this, this->objectName().toUtf8().data(), editor, hint); };
void commitData(QWidget * editor) { callbackQHeaderView_CommitData(this, this->objectName().toUtf8().data(), editor); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQHeaderView_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQHeaderView_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQHeaderView_DropEvent(this, this->objectName().toUtf8().data(), event); };
void edit(const QModelIndex & index) { callbackQHeaderView_Edit(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQHeaderView_Edit2(this, this->objectName().toUtf8().data(), new QModelIndex(index), trigger, event) != 0; };
void editorDestroyed(QObject * editor) { callbackQHeaderView_EditorDestroyed(this, this->objectName().toUtf8().data(), editor); };
void focusInEvent(QFocusEvent * event) { callbackQHeaderView_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQHeaderView_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * event) { callbackQHeaderView_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQHeaderView_IndexAt(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(point).x(), static_cast<QPoint>(point).y()))); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQHeaderView_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQHeaderView_InputMethodQuery(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data(), query)); };
bool isIndexHidden(const QModelIndex & index) const { return callbackQHeaderView_IsIndexHidden(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index)) != 0; };
void keyPressEvent(QKeyEvent * event) { callbackQHeaderView_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyboardSearch(const QString & search) { callbackQHeaderView_KeyboardSearch(this, this->objectName().toUtf8().data(), search.toUtf8().data()); };
QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQHeaderView_MoveCursor(this, this->objectName().toUtf8().data(), cursorAction, modifiers)); };
void resizeEvent(QResizeEvent * event) { callbackQHeaderView_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQHeaderView_RowsAboutToBeRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQHeaderView_RowsInserted(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQHeaderView_ScrollTo(this, this->objectName().toUtf8().data(), new QModelIndex(index), hint); };
void scrollToBottom() { callbackQHeaderView_ScrollToBottom(this, this->objectName().toUtf8().data()); };
void scrollToTop() { callbackQHeaderView_ScrollToTop(this, this->objectName().toUtf8().data()); };
void selectAll() { callbackQHeaderView_SelectAll(this, this->objectName().toUtf8().data()); };
void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQHeaderView_SelectionChanged(this, this->objectName().toUtf8().data(), new QItemSelection(selected), new QItemSelection(deselected)); };
QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQHeaderView_SelectionCommand(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index), const_cast<QEvent*>(event))); };
void setCurrentIndex(const QModelIndex & index) { callbackQHeaderView_SetCurrentIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setRootIndex(const QModelIndex & index) { callbackQHeaderView_SetRootIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQHeaderView_SetSelectionModel(this, this->objectName().toUtf8().data(), selectionModel); };
int sizeHintForColumn(int column) const { return callbackQHeaderView_SizeHintForColumn(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data(), column); };
int sizeHintForRow(int row) const { return callbackQHeaderView_SizeHintForRow(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data(), row); };
void startDrag(Qt::DropActions supportedActions) { callbackQHeaderView_StartDrag(this, this->objectName().toUtf8().data(), supportedActions); };
void update(const QModelIndex & index) { callbackQHeaderView_Update(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void updateGeometries() { callbackQHeaderView_UpdateGeometries(this, this->objectName().toUtf8().data()); };
QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQHeaderView_ViewOptions(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data())); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQHeaderView_ViewportSizeHint(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data())); };
QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQHeaderView_VisualRect(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index))); };
QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQHeaderView_VisualRegionForSelection(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data(), new QItemSelection(selection))); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQHeaderView_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQHeaderView_MinimumSizeHint(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data())); };
void scrollContentsBy(int dx, int dy) { callbackQHeaderView_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void setupViewport(QWidget * viewport) { callbackQHeaderView_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
void wheelEvent(QWheelEvent * e) { callbackQHeaderView_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void changeEvent(QEvent * ev) { callbackQHeaderView_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQHeaderView_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQHeaderView_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQHeaderView_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQHeaderView_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQHeaderView_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQHeaderView_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQHeaderView_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setWindowModified(bool vbo) { callbackQHeaderView_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQHeaderView_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQHeaderView_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQHeaderView_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQHeaderView_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQHeaderView_HasHeightForWidth(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQHeaderView_HeightForWidth(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQHeaderView_Hide(this, this->objectName().toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * event) { callbackQHeaderView_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQHeaderView_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQHeaderView_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQHeaderView_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQHeaderView_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQHeaderView_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQHeaderView_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQHeaderView_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQHeaderView_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQHeaderView_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQHeaderView_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQHeaderView_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQHeaderView_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQHeaderView_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void updateMicroFocus() { callbackQHeaderView_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQHeaderView_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQHeaderView_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQHeaderView_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQHeaderView_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQHeaderView_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQHeaderView_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQHeaderView_MetaObject(const_cast<MyQHeaderView*>(this), this->objectName().toUtf8().data())); };
};
int QHeaderView_CascadingSectionResizes(void* ptr)
{
return static_cast<QHeaderView*>(ptr)->cascadingSectionResizes();
}
int QHeaderView_DefaultAlignment(void* ptr)
{
return static_cast<QHeaderView*>(ptr)->defaultAlignment();
}
int QHeaderView_DefaultSectionSize(void* ptr)
{
return static_cast<QHeaderView*>(ptr)->defaultSectionSize();
}
int QHeaderView_HighlightSections(void* ptr)
{
return static_cast<QHeaderView*>(ptr)->highlightSections();
}
int 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, int enable)
{
static_cast<QHeaderView*>(ptr)->setCascadingSectionResizes(enable != 0);
}
void QHeaderView_SetDefaultAlignment(void* ptr, int 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, int 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, int show)
{
static_cast<QHeaderView*>(ptr)->setSortIndicatorShown(show != 0);
}
void QHeaderView_SetStretchLastSection(void* ptr, int stretch)
{
static_cast<QHeaderView*>(ptr)->setStretchLastSection(stretch != 0);
}
int QHeaderView_StretchLastSection(void* ptr)
{
return static_cast<QHeaderView*>(ptr)->stretchLastSection();
}
void* QHeaderView_NewQHeaderView(int 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));
}
int 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, int 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));
}
int 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();
}
int 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, int mode)
{
static_cast<QHeaderView*>(ptr)->resizeSections(static_cast<QHeaderView::ResizeMode>(mode));
}
void QHeaderView_ResizeSections2(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "resizeSections");
}
int QHeaderView_RestoreState(void* ptr, char* state)
{
return static_cast<QHeaderView*>(ptr)->restoreState(QByteArray(state));
}
char* QHeaderView_SaveState(void* ptr)
{
return QString(static_cast<QHeaderView*>(ptr)->saveState()).toUtf8().data();
}
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);
}
int 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 new QSize(static_cast<QSize>(static_cast<QHeaderView*>(ptr)->sectionSizeFromContents(logicalIndex)).width(), static_cast<QSize>(static_cast<QHeaderView*>(ptr)->sectionSizeFromContents(logicalIndex)).height());
}
void* QHeaderView_SectionSizeFromContentsDefault(void* ptr, int logicalIndex)
{
return new QSize(static_cast<QSize>(static_cast<QHeaderView*>(ptr)->QHeaderView::sectionSizeFromContents(logicalIndex)).width(), static_cast<QSize>(static_cast<QHeaderView*>(ptr)->QHeaderView::sectionSizeFromContents(logicalIndex)).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));
}
int QHeaderView_SectionsClickable(void* ptr)
{
return static_cast<QHeaderView*>(ptr)->sectionsClickable();
}
int 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));
}
int QHeaderView_SectionsMovable(void* ptr)
{
return static_cast<QHeaderView*>(ptr)->sectionsMovable();
}
int 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, int hide)
{
static_cast<QHeaderView*>(ptr)->setSectionHidden(logicalIndex, hide != 0);
}
void QHeaderView_SetSectionResizeMode(void* ptr, int mode)
{
static_cast<QHeaderView*>(ptr)->setSectionResizeMode(static_cast<QHeaderView::ResizeMode>(mode));
}
void QHeaderView_SetSectionResizeMode2(void* ptr, int logicalIndex, int mode)
{
static_cast<QHeaderView*>(ptr)->setSectionResizeMode(logicalIndex, static_cast<QHeaderView::ResizeMode>(mode));
}
void QHeaderView_SetSectionsClickable(void* ptr, int clickable)
{
static_cast<QHeaderView*>(ptr)->setSectionsClickable(clickable != 0);
}
void QHeaderView_SetSectionsMovable(void* ptr, int movable)
{
static_cast<QHeaderView*>(ptr)->setSectionsMovable(movable != 0);
}
void QHeaderView_SetSelection(void* ptr, void* rect, int flags)
{
static_cast<QHeaderView*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
}
void QHeaderView_SetSelectionDefault(void* ptr, void* rect, int flags)
{
static_cast<QHeaderView*>(ptr)->QHeaderView::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
}
void QHeaderView_SetSortIndicator(void* ptr, int logicalIndex, int order)
{
static_cast<QHeaderView*>(ptr)->setSortIndicator(logicalIndex, static_cast<Qt::SortOrder>(order));
}
void QHeaderView_SetVisible(void* ptr, int v)
{
static_cast<QHeaderView*>(ptr)->setVisible(v != 0);
}
void QHeaderView_SetVisibleDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QHeaderView*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QHeaderView*>(ptr)->sizeHint()).height());
}
void* QHeaderView_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QHeaderView*>(ptr)->QHeaderView::sizeHint()).width(), static_cast<QSize>(static_cast<QHeaderView*>(ptr)->QHeaderView::sizeHint()).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, int order)
{
static_cast<QHeaderView*>(ptr)->sortIndicatorChanged(logicalIndex, static_cast<Qt::SortOrder>(order));
}
int 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();
}
int QHeaderView_ViewportEvent(void* ptr, void* e)
{
return static_cast<QHeaderView*>(ptr)->viewportEvent(static_cast<QEvent*>(e));
}
int 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_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, int 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, int 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));
}
int QHeaderView_Edit2(void* ptr, void* index, int trigger, void* event)
{
return static_cast<QHeaderView*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}
int QHeaderView_Edit2Default(void* ptr, void* index, int 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));
}
int QHeaderView_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QHeaderView*>(ptr)->focusNextPrevChild(next != 0);
}
int QHeaderView_FocusNextPrevChildDefault(void* ptr, int 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, int query)
{
return new QVariant(static_cast<QHeaderView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QHeaderView_InputMethodQueryDefault(void* ptr, int query)
{
return new QVariant(static_cast<QHeaderView*>(ptr)->QHeaderView::inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
int QHeaderView_IsIndexHidden(void* ptr, void* index)
{
return static_cast<QHeaderView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}
int 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, int cursorAction, int modifiers)
{
return new QModelIndex(static_cast<QHeaderView*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}
void* QHeaderView_MoveCursorDefault(void* ptr, int cursorAction, int 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, int hint)
{
static_cast<QHeaderView*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}
void QHeaderView_ScrollToDefault(void* ptr, void* index, int 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));
}
int QHeaderView_SelectionCommand(void* ptr, void* index, void* event)
{
return static_cast<QHeaderView*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}
int 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, int supportedActions)
{
static_cast<QHeaderView*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}
void QHeaderView_StartDragDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QHeaderView*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QHeaderView*>(ptr)->viewportSizeHint()).height());
}
void* QHeaderView_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QHeaderView*>(ptr)->QHeaderView::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QHeaderView*>(ptr)->QHeaderView::viewportSizeHint()).height());
}
void* QHeaderView_VisualRect(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QHeaderView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QHeaderView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QHeaderView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QHeaderView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).height());
}
void* QHeaderView_VisualRectDefault(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QHeaderView*>(ptr)->QHeaderView::visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QHeaderView*>(ptr)->QHeaderView::visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QHeaderView*>(ptr)->QHeaderView::visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QHeaderView*>(ptr)->QHeaderView::visualRect(*static_cast<QModelIndex*>(index))).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 new QSize(static_cast<QSize>(static_cast<QHeaderView*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QHeaderView*>(ptr)->minimumSizeHint()).height());
}
void* QHeaderView_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QHeaderView*>(ptr)->QHeaderView::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QHeaderView*>(ptr)->QHeaderView::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QHeaderView_SetEnabledDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QHeaderView_SetWindowModifiedDefault(void* ptr, int 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));
}
int QHeaderView_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QHeaderView_HasHeightForWidth(void* ptr)
{
return static_cast<QHeaderView*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QHeaderView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QHeaderView*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QHeaderView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QHeaderView*>(ptr)->QHeaderView::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QHeaderView_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QHeaderView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QHeaderView_SetHiddenDefault(void* ptr, int 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));
}
int QHeaderView_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QHeaderView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), result); };
void Signal_IntValueChanged(int value) { callbackQInputDialog_IntValueChanged(this, this->objectName().toUtf8().data(), value); };
void Signal_IntValueSelected(int value) { callbackQInputDialog_IntValueSelected(this, this->objectName().toUtf8().data(), value); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQInputDialog_MinimumSizeHint(const_cast<MyQInputDialog*>(this), this->objectName().toUtf8().data())); };
void setVisible(bool visible) { callbackQInputDialog_SetVisible(this, this->objectName().toUtf8().data(), visible); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQInputDialog_SizeHint(const_cast<MyQInputDialog*>(this), this->objectName().toUtf8().data())); };
void Signal_TextValueChanged(const QString & text) { callbackQInputDialog_TextValueChanged(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void Signal_TextValueSelected(const QString & text) { callbackQInputDialog_TextValueSelected(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void accept() { callbackQInputDialog_Accept(this, this->objectName().toUtf8().data()); };
void closeEvent(QCloseEvent * e) { callbackQInputDialog_CloseEvent(this, this->objectName().toUtf8().data(), e); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQInputDialog_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
int exec() { return callbackQInputDialog_Exec(this, this->objectName().toUtf8().data()); };
void keyPressEvent(QKeyEvent * e) { callbackQInputDialog_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void reject() { callbackQInputDialog_Reject(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * vqr) { callbackQInputDialog_ResizeEvent(this, this->objectName().toUtf8().data(), vqr); };
void showEvent(QShowEvent * event) { callbackQInputDialog_ShowEvent(this, this->objectName().toUtf8().data(), event); };
void actionEvent(QActionEvent * event) { callbackQInputDialog_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQInputDialog_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQInputDialog_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQInputDialog_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQInputDialog_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQInputDialog_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQInputDialog_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQInputDialog_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQInputDialog_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQInputDialog_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQInputDialog_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQInputDialog_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQInputDialog_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQInputDialog_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setWindowModified(bool vbo) { callbackQInputDialog_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQInputDialog_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void changeEvent(QEvent * event) { callbackQInputDialog_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQInputDialog_Close(this, this->objectName().toUtf8().data()) != 0; };
bool focusNextPrevChild(bool next) { return callbackQInputDialog_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQInputDialog_HasHeightForWidth(const_cast<MyQInputDialog*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQInputDialog_HeightForWidth(const_cast<MyQInputDialog*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQInputDialog_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQInputDialog_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQInputDialog_InputMethodQuery(const_cast<MyQInputDialog*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQInputDialog_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQInputDialog_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQInputDialog_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQInputDialog_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQInputDialog_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQInputDialog_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQInputDialog_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQInputDialog_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQInputDialog_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQInputDialog_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQInputDialog_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQInputDialog_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQInputDialog_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQInputDialog_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQInputDialog_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQInputDialog_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQInputDialog_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQInputDialog_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQInputDialog_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQInputDialog_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQInputDialog_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQInputDialog_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQInputDialog_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQInputDialog_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQInputDialog_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQInputDialog_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQInputDialog_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQInputDialog_MetaObject(const_cast<MyQInputDialog*>(this), this->objectName().toUtf8().data())); };
};
char* QInputDialog_CancelButtonText(void* ptr)
{
return static_cast<QInputDialog*>(ptr)->cancelButtonText().toUtf8().data();
}
char* QInputDialog_ComboBoxItems(void* ptr)
{
return static_cast<QInputDialog*>(ptr)->comboBoxItems().join("|").toUtf8().data();
}
int QInputDialog_DoubleDecimals(void* ptr)
{
return static_cast<QInputDialog*>(ptr)->doubleDecimals();
}
int 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();
}
int QInputDialog_IsComboBoxEditable(void* ptr)
{
return static_cast<QInputDialog*>(ptr)->isComboBoxEditable();
}
char* QInputDialog_LabelText(void* ptr)
{
return static_cast<QInputDialog*>(ptr)->labelText().toUtf8().data();
}
char* QInputDialog_OkButtonText(void* ptr)
{
return static_cast<QInputDialog*>(ptr)->okButtonText().toUtf8().data();
}
int 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, int 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_SetInputMode(void* ptr, int 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, int options)
{
static_cast<QInputDialog*>(ptr)->setOptions(static_cast<QInputDialog::InputDialogOption>(options));
}
void QInputDialog_SetTextEchoMode(void* ptr, int 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));
}
int QInputDialog_TextEchoMode(void* ptr)
{
return static_cast<QInputDialog*>(ptr)->textEchoMode();
}
char* QInputDialog_TextValue(void* ptr)
{
return static_cast<QInputDialog*>(ptr)->textValue().toUtf8().data();
}
void* QInputDialog_NewQInputDialog(void* parent, int 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);
}
int QInputDialog_QInputDialog_GetInt(void* parent, char* title, char* label, int value, int min, int max, int step, int ok, int 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, int editable, int ok, int flags, int inputMethodHints)
{
return 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().data();
}
char* QInputDialog_QInputDialog_GetMultiLineText(void* parent, char* title, char* label, char* text, int ok, int flags, int inputMethodHints)
{
return QInputDialog::getMultiLineText(static_cast<QWidget*>(parent), QString(title), QString(label), QString(text), NULL, static_cast<Qt::WindowType>(flags), static_cast<Qt::InputMethodHint>(inputMethodHints)).toUtf8().data();
}
char* QInputDialog_QInputDialog_GetText(void* parent, char* title, char* label, int mode, char* text, int ok, int flags, int inputMethodHints)
{
return 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().data();
}
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 new QSize(static_cast<QSize>(static_cast<QInputDialog*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QInputDialog*>(ptr)->minimumSizeHint()).height());
}
void* QInputDialog_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QInputDialog*>(ptr)->QInputDialog::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QInputDialog*>(ptr)->QInputDialog::minimumSizeHint()).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_SetIntRange(void* ptr, int min, int max)
{
static_cast<QInputDialog*>(ptr)->setIntRange(min, max);
}
void QInputDialog_SetOption(void* ptr, int option, int on)
{
static_cast<QInputDialog*>(ptr)->setOption(static_cast<QInputDialog::InputDialogOption>(option), on != 0);
}
void QInputDialog_SetVisible(void* ptr, int visible)
{
static_cast<QInputDialog*>(ptr)->setVisible(visible != 0);
}
void QInputDialog_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QInputDialog*>(ptr)->QInputDialog::setVisible(visible != 0);
}
void* QInputDialog_SizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QInputDialog*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QInputDialog*>(ptr)->sizeHint()).height());
}
void* QInputDialog_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QInputDialog*>(ptr)->QInputDialog::sizeHint()).width(), static_cast<QSize>(static_cast<QInputDialog*>(ptr)->QInputDialog::sizeHint()).height());
}
int QInputDialog_TestOption(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QInputDialog_SetEnabledDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QInputDialog_SetWindowModifiedDefault(void* ptr, int 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));
}
int QInputDialog_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QInputDialog_CloseDefault(void* ptr)
{
return static_cast<QInputDialog*>(ptr)->QInputDialog::close();
}
int QInputDialog_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QInputDialog*>(ptr)->focusNextPrevChild(next != 0);
}
int QInputDialog_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QInputDialog*>(ptr)->QInputDialog::focusNextPrevChild(next != 0);
}
int QInputDialog_HasHeightForWidth(void* ptr)
{
return static_cast<QInputDialog*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QInputDialog*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QInputDialog_InputMethodQueryDefault(void* ptr, int 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));
}
int QInputDialog_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QInputDialog*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QInputDialog_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QInputDialog*>(ptr)->QInputDialog::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QInputDialog_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QInputDialog*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QInputDialog_SetHiddenDefault(void* ptr, int 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), this->objectName().toUtf8().data(), parent, new QStyleOptionViewItem(option), new QModelIndex(index))); };
void drawCheck(QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect, Qt::CheckState state) const { callbackQItemDelegate_DrawCheck(const_cast<MyQItemDelegate*>(this), this->objectName().toUtf8().data(), painter, new QStyleOptionViewItem(option), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), state); };
void drawDecoration(QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect, const QPixmap & pixmap) const { callbackQItemDelegate_DrawDecoration(const_cast<MyQItemDelegate*>(this), this->objectName().toUtf8().data(), painter, new QStyleOptionViewItem(option), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), new QPixmap(pixmap)); };
void drawDisplay(QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect, const QString & text) const { callbackQItemDelegate_DrawDisplay(const_cast<MyQItemDelegate*>(this), this->objectName().toUtf8().data(), painter, new QStyleOptionViewItem(option), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), text.toUtf8().data()); };
void drawFocus(QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect) const { callbackQItemDelegate_DrawFocus(const_cast<MyQItemDelegate*>(this), this->objectName().toUtf8().data(), painter, new QStyleOptionViewItem(option), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height())); };
bool editorEvent(QEvent * event, QAbstractItemModel * model, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQItemDelegate_EditorEvent(this, this->objectName().toUtf8().data(), event, model, new QStyleOptionViewItem(option), new QModelIndex(index)) != 0; };
void paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQItemDelegate_Paint(const_cast<MyQItemDelegate*>(this), this->objectName().toUtf8().data(), painter, new QStyleOptionViewItem(option), new QModelIndex(index)); };
void setEditorData(QWidget * editor, const QModelIndex & index) const { callbackQItemDelegate_SetEditorData(const_cast<MyQItemDelegate*>(this), this->objectName().toUtf8().data(), editor, new QModelIndex(index)); };
void setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex & index) const { callbackQItemDelegate_SetModelData(const_cast<MyQItemDelegate*>(this), this->objectName().toUtf8().data(), editor, model, new QModelIndex(index)); };
QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex & index) const { return *static_cast<QSize*>(callbackQItemDelegate_SizeHint(const_cast<MyQItemDelegate*>(this), this->objectName().toUtf8().data(), new QStyleOptionViewItem(option), new QModelIndex(index))); };
void updateEditorGeometry(QWidget * editor, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQItemDelegate_UpdateEditorGeometry(const_cast<MyQItemDelegate*>(this), this->objectName().toUtf8().data(), editor, new QStyleOptionViewItem(option), new QModelIndex(index)); };
void destroyEditor(QWidget * editor, const QModelIndex & index) const { callbackQItemDelegate_DestroyEditor(const_cast<MyQItemDelegate*>(this), this->objectName().toUtf8().data(), editor, new QModelIndex(index)); };
bool helpEvent(QHelpEvent * event, QAbstractItemView * view, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQItemDelegate_HelpEvent(this, this->objectName().toUtf8().data(), event, view, new QStyleOptionViewItem(option), new QModelIndex(index)) != 0; };
void timerEvent(QTimerEvent * event) { callbackQItemDelegate_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQItemDelegate_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQItemDelegate_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQItemDelegate_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQItemDelegate_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQItemDelegate_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQItemDelegate_Event(this, this->objectName().toUtf8().data(), e) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQItemDelegate_MetaObject(const_cast<MyQItemDelegate*>(this), this->objectName().toUtf8().data())); };
};
int QItemDelegate_EventFilter(void* ptr, void* editor, void* event)
{
return static_cast<QItemDelegate*>(ptr)->eventFilter(static_cast<QObject*>(editor), static_cast<QEvent*>(event));
}
int QItemDelegate_HasClipping(void* ptr)
{
return static_cast<QItemDelegate*>(ptr)->hasClipping();
}
void QItemDelegate_SetClipping(void* ptr, int 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, int 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, int 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));
}
int 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));
}
int 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 new QSize(static_cast<QSize>(static_cast<QItemDelegate*>(ptr)->sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index))).width(), static_cast<QSize>(static_cast<QItemDelegate*>(ptr)->sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index))).height());
}
void* QItemDelegate_SizeHintDefault(void* ptr, void* option, void* index)
{
return new QSize(static_cast<QSize>(static_cast<QItemDelegate*>(ptr)->QItemDelegate::sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index))).width(), static_cast<QSize>(static_cast<QItemDelegate*>(ptr)->QItemDelegate::sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index))).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));
}
int 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));
}
int 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));
}
int QItemDelegate_Event(void* ptr, void* e)
{
return static_cast<QItemDelegate*>(ptr)->event(static_cast<QEvent*>(e));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
QWidget * createWidget(QWidget * parent) const { return static_cast<QWidget*>(callbackQItemEditorCreatorBase_CreateWidget(const_cast<MyQItemEditorCreatorBase*>(this), this->objectNameAbs().toUtf8().data(), parent)); };
QByteArray valuePropertyName() const { return QByteArray(callbackQItemEditorCreatorBase_ValuePropertyName(const_cast<MyQItemEditorCreatorBase*>(this), this->objectNameAbs().toUtf8().data())); };
};
void QItemEditorCreatorBase_DestroyQItemEditorCreatorBase(void* ptr)
{
static_cast<QItemEditorCreatorBase*>(ptr)->~QItemEditorCreatorBase();
}
void* QItemEditorCreatorBase_CreateWidget(void* ptr, void* parent)
{
return static_cast<QItemEditorCreatorBase*>(ptr)->createWidget(static_cast<QWidget*>(parent));
}
char* QItemEditorCreatorBase_ValuePropertyName(void* ptr)
{
return QString(static_cast<QItemEditorCreatorBase*>(ptr)->valuePropertyName()).toUtf8().data();
}
char* QItemEditorCreatorBase_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQItemEditorCreatorBase*>(static_cast<QItemEditorCreatorBase*>(ptr))) {
return static_cast<MyQItemEditorCreatorBase*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QItemEditorCreatorBase_BASE").toUtf8().data();
}
void QItemEditorCreatorBase_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQItemEditorCreatorBase*>(static_cast<QItemEditorCreatorBase*>(ptr))) {
static_cast<MyQItemEditorCreatorBase*>(ptr)->setObjectNameAbs(QString(name));
}
}
class MyQItemEditorFactory: public QItemEditorFactory
{
public:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQItemEditorFactory() : QItemEditorFactory() {};
QWidget * createEditor(int userType, QWidget * parent) const { return static_cast<QWidget*>(callbackQItemEditorFactory_CreateEditor(const_cast<MyQItemEditorFactory*>(this), this->objectNameAbs().toUtf8().data(), userType, parent)); };
QByteArray valuePropertyName(int userType) const { return QByteArray(callbackQItemEditorFactory_ValuePropertyName(const_cast<MyQItemEditorFactory*>(this), this->objectNameAbs().toUtf8().data(), userType)); };
};
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 QString(static_cast<QItemEditorFactory*>(ptr)->valuePropertyName(userType)).toUtf8().data();
}
char* QItemEditorFactory_ValuePropertyNameDefault(void* ptr, int userType)
{
return QString(static_cast<QItemEditorFactory*>(ptr)->QItemEditorFactory::valuePropertyName(userType)).toUtf8().data();
}
void QItemEditorFactory_DestroyQItemEditorFactory(void* ptr)
{
static_cast<QItemEditorFactory*>(ptr)->~QItemEditorFactory();
}
char* QItemEditorFactory_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQItemEditorFactory*>(static_cast<QItemEditorFactory*>(ptr))) {
return static_cast<MyQItemEditorFactory*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QItemEditorFactory_BASE").toUtf8().data();
}
void QItemEditorFactory_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQItemEditorFactory*>(static_cast<QItemEditorFactory*>(ptr))) {
static_cast<MyQItemEditorFactory*>(ptr)->setObjectNameAbs(QString(name));
}
}
void* QKeyEventTransition_NewQKeyEventTransition2(void* object, int 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));
}
int 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();
}
int 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, int modifierMask)
{
static_cast<QKeyEventTransition*>(ptr)->setModifierMask(static_cast<Qt::KeyboardModifier>(modifierMask));
}
void QKeyEventTransition_DestroyQKeyEventTransition(void* ptr)
{
static_cast<QKeyEventTransition*>(ptr)->~QKeyEventTransition();
}
int QKeyEventTransition_Event(void* ptr, void* e)
{
return static_cast<QKeyEventTransition*>(ptr)->event(static_cast<QEvent*>(e));
}
int 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));
}
int QKeyEventTransition_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QKeyEventTransition*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), new QKeySequence(keySequence)); };
void clear() { callbackQKeySequenceEdit_Clear(this, this->objectName().toUtf8().data()); };
void Signal_EditingFinished() { callbackQKeySequenceEdit_EditingFinished(this, this->objectName().toUtf8().data()); };
void keyPressEvent(QKeyEvent * e) { callbackQKeySequenceEdit_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void keyReleaseEvent(QKeyEvent * e) { callbackQKeySequenceEdit_KeyReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void Signal_KeySequenceChanged(const QKeySequence & keySequence) { callbackQKeySequenceEdit_KeySequenceChanged(this, this->objectName().toUtf8().data(), new QKeySequence(keySequence)); };
void actionEvent(QActionEvent * event) { callbackQKeySequenceEdit_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQKeySequenceEdit_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQKeySequenceEdit_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQKeySequenceEdit_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQKeySequenceEdit_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQKeySequenceEdit_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQKeySequenceEdit_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQKeySequenceEdit_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQKeySequenceEdit_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQKeySequenceEdit_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQKeySequenceEdit_MinimumSizeHint(const_cast<MyQKeySequenceEdit*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQKeySequenceEdit_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQKeySequenceEdit_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQKeySequenceEdit_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQKeySequenceEdit_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQKeySequenceEdit_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQKeySequenceEdit_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQKeySequenceEdit_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQKeySequenceEdit_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQKeySequenceEdit_SizeHint(const_cast<MyQKeySequenceEdit*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * event) { callbackQKeySequenceEdit_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQKeySequenceEdit_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQKeySequenceEdit_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQKeySequenceEdit_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQKeySequenceEdit_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQKeySequenceEdit_HasHeightForWidth(const_cast<MyQKeySequenceEdit*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQKeySequenceEdit_HeightForWidth(const_cast<MyQKeySequenceEdit*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQKeySequenceEdit_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQKeySequenceEdit_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQKeySequenceEdit_InputMethodQuery(const_cast<MyQKeySequenceEdit*>(this), this->objectName().toUtf8().data(), query)); };
void lower() { callbackQKeySequenceEdit_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQKeySequenceEdit_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQKeySequenceEdit_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQKeySequenceEdit_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQKeySequenceEdit_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQKeySequenceEdit_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQKeySequenceEdit_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQKeySequenceEdit_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQKeySequenceEdit_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQKeySequenceEdit_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQKeySequenceEdit_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQKeySequenceEdit_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQKeySequenceEdit_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQKeySequenceEdit_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQKeySequenceEdit_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQKeySequenceEdit_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQKeySequenceEdit_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQKeySequenceEdit_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQKeySequenceEdit_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQKeySequenceEdit_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQKeySequenceEdit_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQKeySequenceEdit_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQKeySequenceEdit_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQKeySequenceEdit_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQKeySequenceEdit_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQKeySequenceEdit_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQKeySequenceEdit_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQKeySequenceEdit_MetaObject(const_cast<MyQKeySequenceEdit*>(this), this->objectName().toUtf8().data())); };
};
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();
}
int 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 new QSize(static_cast<QSize>(static_cast<QKeySequenceEdit*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QKeySequenceEdit*>(ptr)->minimumSizeHint()).height());
}
void* QKeySequenceEdit_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QKeySequenceEdit_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QKeySequenceEdit_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::setVisible(visible != 0);
}
void QKeySequenceEdit_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QKeySequenceEdit_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QKeySequenceEdit*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QKeySequenceEdit*>(ptr)->sizeHint()).height());
}
void* QKeySequenceEdit_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::sizeHint()).width(), static_cast<QSize>(static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::sizeHint()).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));
}
int QKeySequenceEdit_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QKeySequenceEdit_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QKeySequenceEdit*>(ptr)->focusNextPrevChild(next != 0);
}
int QKeySequenceEdit_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::focusNextPrevChild(next != 0);
}
int QKeySequenceEdit_HasHeightForWidth(void* ptr)
{
return static_cast<QKeySequenceEdit*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QKeySequenceEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QKeySequenceEdit_InputMethodQueryDefault(void* ptr, int 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));
}
int QKeySequenceEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QKeySequenceEdit*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QKeySequenceEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QKeySequenceEdit*>(ptr)->QKeySequenceEdit::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QKeySequenceEdit_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QKeySequenceEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QKeySequenceEdit_SetHiddenDefault(void* ptr, int 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));
}
int QKeySequenceEdit_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QKeySequenceEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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) {};
void setSmallDecimalPoint(bool vbo) { callbackQLCDNumber_SetSmallDecimalPoint(this, this->objectName().toUtf8().data(), vbo); };
void display(const QString & s) { callbackQLCDNumber_Display(this, this->objectName().toUtf8().data(), s.toUtf8().data()); };
void display(int num) { callbackQLCDNumber_Display2(this, this->objectName().toUtf8().data(), num); };
void Signal_Overflow() { callbackQLCDNumber_Overflow(this, this->objectName().toUtf8().data()); };
void paintEvent(QPaintEvent * vqp) { callbackQLCDNumber_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
void setBinMode() { callbackQLCDNumber_SetBinMode(this, this->objectName().toUtf8().data()); };
void setDecMode() { callbackQLCDNumber_SetDecMode(this, this->objectName().toUtf8().data()); };
void setHexMode() { callbackQLCDNumber_SetHexMode(this, this->objectName().toUtf8().data()); };
void setOctMode() { callbackQLCDNumber_SetOctMode(this, this->objectName().toUtf8().data()); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQLCDNumber_SizeHint(const_cast<MyQLCDNumber*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * ev) { callbackQLCDNumber_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQLCDNumber_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQLCDNumber_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQLCDNumber_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQLCDNumber_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQLCDNumber_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQLCDNumber_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQLCDNumber_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQLCDNumber_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQLCDNumber_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQLCDNumber_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQLCDNumber_MinimumSizeHint(const_cast<MyQLCDNumber*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQLCDNumber_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQLCDNumber_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQLCDNumber_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQLCDNumber_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQLCDNumber_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQLCDNumber_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQLCDNumber_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQLCDNumber_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQLCDNumber_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQLCDNumber_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQLCDNumber_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQLCDNumber_HasHeightForWidth(const_cast<MyQLCDNumber*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQLCDNumber_HeightForWidth(const_cast<MyQLCDNumber*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQLCDNumber_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQLCDNumber_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQLCDNumber_InputMethodQuery(const_cast<MyQLCDNumber*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQLCDNumber_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQLCDNumber_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQLCDNumber_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQLCDNumber_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQLCDNumber_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQLCDNumber_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQLCDNumber_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQLCDNumber_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQLCDNumber_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQLCDNumber_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQLCDNumber_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQLCDNumber_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQLCDNumber_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQLCDNumber_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQLCDNumber_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQLCDNumber_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQLCDNumber_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQLCDNumber_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQLCDNumber_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQLCDNumber_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQLCDNumber_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQLCDNumber_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQLCDNumber_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQLCDNumber_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQLCDNumber_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQLCDNumber_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQLCDNumber_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQLCDNumber_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQLCDNumber_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQLCDNumber_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLCDNumber_MetaObject(const_cast<MyQLCDNumber*>(this), this->objectName().toUtf8().data())); };
};
int QLCDNumber_IntValue(void* ptr)
{
return static_cast<QLCDNumber*>(ptr)->intValue();
}
int QLCDNumber_Mode(void* ptr)
{
return static_cast<QLCDNumber*>(ptr)->mode();
}
int QLCDNumber_SegmentStyle(void* ptr)
{
return static_cast<QLCDNumber*>(ptr)->segmentStyle();
}
void QLCDNumber_SetMode(void* ptr, int vmo)
{
static_cast<QLCDNumber*>(ptr)->setMode(static_cast<QLCDNumber::Mode>(vmo));
}
void QLCDNumber_SetSegmentStyle(void* ptr, int vse)
{
static_cast<QLCDNumber*>(ptr)->setSegmentStyle(static_cast<QLCDNumber::SegmentStyle>(vse));
}
void QLCDNumber_SetSmallDecimalPoint(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setSmallDecimalPoint", Q_ARG(bool, vbo != 0));
}
int QLCDNumber_SmallDecimalPoint(void* ptr)
{
return static_cast<QLCDNumber*>(ptr)->smallDecimalPoint();
}
void* QLCDNumber_NewQLCDNumber(void* parent)
{
return new MyQLCDNumber(static_cast<QWidget*>(parent));
}
int 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_Display2(void* ptr, int num)
{
QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "display", Q_ARG(int, num));
}
int 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 new QSize(static_cast<QSize>(static_cast<QLCDNumber*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QLCDNumber*>(ptr)->sizeHint()).height());
}
void* QLCDNumber_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QLCDNumber*>(ptr)->QLCDNumber::sizeHint()).width(), static_cast<QSize>(static_cast<QLCDNumber*>(ptr)->QLCDNumber::sizeHint()).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 new QSize(static_cast<QSize>(static_cast<QLCDNumber*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QLCDNumber*>(ptr)->minimumSizeHint()).height());
}
void* QLCDNumber_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QLCDNumber*>(ptr)->QLCDNumber::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QLCDNumber*>(ptr)->QLCDNumber::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QLCDNumber_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QLCDNumber_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QLCDNumber*>(ptr)->QLCDNumber::setVisible(visible != 0);
}
void QLCDNumber_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QLCDNumber_SetWindowModifiedDefault(void* ptr, int 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));
}
int QLCDNumber_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QLCDNumber_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QLCDNumber*>(ptr)->focusNextPrevChild(next != 0);
}
int QLCDNumber_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QLCDNumber*>(ptr)->QLCDNumber::focusNextPrevChild(next != 0);
}
int QLCDNumber_HasHeightForWidth(void* ptr)
{
return static_cast<QLCDNumber*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QLCDNumber*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QLCDNumber_InputMethodQueryDefault(void* ptr, int 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));
}
int QLCDNumber_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QLCDNumber*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QLCDNumber_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QLCDNumber*>(ptr)->QLCDNumber::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QLCDNumber_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QLCDNumber*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QLCDNumber_SetHiddenDefault(void* ptr, int 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));
}
int QLCDNumber_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QLCDNumber*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), new QPixmap(vqp)); };
void setText(const QString & vqs) { callbackQLabel_SetText(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void changeEvent(QEvent * ev) { callbackQLabel_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void clear() { callbackQLabel_Clear(this, this->objectName().toUtf8().data()); };
void contextMenuEvent(QContextMenuEvent * ev) { callbackQLabel_ContextMenuEvent(this, this->objectName().toUtf8().data(), ev); };
void focusInEvent(QFocusEvent * ev) { callbackQLabel_FocusInEvent(this, this->objectName().toUtf8().data(), ev); };
bool focusNextPrevChild(bool next) { return callbackQLabel_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * ev) { callbackQLabel_FocusOutEvent(this, this->objectName().toUtf8().data(), ev); };
int heightForWidth(int w) const { return callbackQLabel_HeightForWidth(const_cast<MyQLabel*>(this), this->objectName().toUtf8().data(), w); };
void keyPressEvent(QKeyEvent * ev) { callbackQLabel_KeyPressEvent(this, this->objectName().toUtf8().data(), ev); };
void Signal_LinkActivated(const QString & link) { callbackQLabel_LinkActivated(this, this->objectName().toUtf8().data(), link.toUtf8().data()); };
void Signal_LinkHovered(const QString & link) { callbackQLabel_LinkHovered(this, this->objectName().toUtf8().data(), link.toUtf8().data()); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQLabel_MinimumSizeHint(const_cast<MyQLabel*>(this), this->objectName().toUtf8().data())); };
void mouseMoveEvent(QMouseEvent * ev) { callbackQLabel_MouseMoveEvent(this, this->objectName().toUtf8().data(), ev); };
void mousePressEvent(QMouseEvent * ev) { callbackQLabel_MousePressEvent(this, this->objectName().toUtf8().data(), ev); };
void mouseReleaseEvent(QMouseEvent * ev) { callbackQLabel_MouseReleaseEvent(this, this->objectName().toUtf8().data(), ev); };
void paintEvent(QPaintEvent * vqp) { callbackQLabel_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
void setMovie(QMovie * movie) { callbackQLabel_SetMovie(this, this->objectName().toUtf8().data(), movie); };
void setNum(int num) { callbackQLabel_SetNum(this, this->objectName().toUtf8().data(), num); };
void setPicture(const QPicture & picture) { callbackQLabel_SetPicture(this, this->objectName().toUtf8().data(), new QPicture(picture)); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQLabel_SizeHint(const_cast<MyQLabel*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQLabel_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQLabel_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQLabel_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQLabel_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQLabel_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQLabel_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQLabel_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQLabel_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQLabel_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQLabel_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQLabel_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQLabel_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQLabel_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQLabel_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQLabel_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQLabel_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQLabel_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQLabel_HasHeightForWidth(const_cast<MyQLabel*>(this), this->objectName().toUtf8().data()) != 0; };
void hide() { callbackQLabel_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQLabel_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQLabel_InputMethodQuery(const_cast<MyQLabel*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQLabel_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQLabel_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQLabel_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQLabel_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQLabel_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQLabel_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQLabel_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQLabel_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQLabel_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQLabel_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQLabel_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQLabel_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQLabel_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQLabel_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQLabel_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQLabel_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQLabel_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQLabel_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQLabel_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQLabel_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQLabel_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQLabel_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQLabel_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQLabel_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQLabel_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQLabel_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLabel_MetaObject(const_cast<MyQLabel*>(this), this->objectName().toUtf8().data())); };
};
int QLabel_Alignment(void* ptr)
{
return static_cast<QLabel*>(ptr)->alignment();
}
int QLabel_HasScaledContents(void* ptr)
{
return static_cast<QLabel*>(ptr)->hasScaledContents();
}
int 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();
}
int 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 static_cast<QLabel*>(ptr)->selectedText().toUtf8().data();
}
void QLabel_SetAlignment(void* ptr, int 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, int 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, int 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, int vqt)
{
static_cast<QLabel*>(ptr)->setTextFormat(static_cast<Qt::TextFormat>(vqt));
}
void QLabel_SetTextInteractionFlags(void* ptr, int flags)
{
static_cast<QLabel*>(ptr)->setTextInteractionFlags(static_cast<Qt::TextInteractionFlag>(flags));
}
void QLabel_SetWordWrap(void* ptr, int on)
{
static_cast<QLabel*>(ptr)->setWordWrap(on != 0);
}
char* QLabel_Text(void* ptr)
{
return static_cast<QLabel*>(ptr)->text().toUtf8().data();
}
int QLabel_TextFormat(void* ptr)
{
return static_cast<QLabel*>(ptr)->textFormat();
}
int QLabel_TextInteractionFlags(void* ptr)
{
return static_cast<QLabel*>(ptr)->textInteractionFlags();
}
int QLabel_WordWrap(void* ptr)
{
return static_cast<QLabel*>(ptr)->wordWrap();
}
void* QLabel_NewQLabel(void* parent, int f)
{
return new MyQLabel(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
}
void* QLabel_NewQLabel2(char* text, void* parent, int 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));
}
int 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));
}
int QLabel_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QLabel*>(ptr)->focusNextPrevChild(next != 0);
}
int QLabel_FocusNextPrevChildDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QLabel*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QLabel*>(ptr)->minimumSizeHint()).height());
}
void* QLabel_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QLabel*>(ptr)->QLabel::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QLabel*>(ptr)->QLabel::minimumSizeHint()).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_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 new QSize(static_cast<QSize>(static_cast<QLabel*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QLabel*>(ptr)->sizeHint()).height());
}
void* QLabel_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QLabel*>(ptr)->QLabel::sizeHint()).width(), static_cast<QSize>(static_cast<QLabel*>(ptr)->QLabel::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QLabel_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QLabel_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QLabel*>(ptr)->QLabel::setVisible(visible != 0);
}
void QLabel_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QLabel_SetWindowModifiedDefault(void* ptr, int 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));
}
int QLabel_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QLabel_HasHeightForWidth(void* ptr)
{
return static_cast<QLabel*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QLabel*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QLabel_InputMethodQueryDefault(void* ptr, int 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));
}
int QLabel_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QLabel*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QLabel_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QLabel*>(ptr)->QLabel::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QLabel_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QLabel*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QLabel_SetHiddenDefault(void* ptr, int 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));
}
int QLabel_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QLabel*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), item); };
QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayout_ControlTypes(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data())); };
int count() const { return callbackQLayout_Count(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data()); };
Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQLayout_ExpandingDirections(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data())); };
QRect geometry() const { return *static_cast<QRect*>(callbackQLayout_Geometry(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data())); };
int indexOf(QWidget * widget) const { return callbackQLayout_IndexOf(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data(), widget); };
void invalidate() { callbackQLayout_Invalidate(this, this->objectName().toUtf8().data()); };
bool isEmpty() const { return callbackQLayout_IsEmpty(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data()) != 0; };
QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQLayout_ItemAt(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data(), index)); };
QLayout * layout() { return static_cast<QLayout*>(callbackQLayout_Layout(this, this->objectName().toUtf8().data())); };
QSize maximumSize() const { return *static_cast<QSize*>(callbackQLayout_MaximumSize(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data())); };
QSize minimumSize() const { return *static_cast<QSize*>(callbackQLayout_MinimumSize(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data())); };
void setGeometry(const QRect & r) { callbackQLayout_SetGeometry(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(r).x(), static_cast<QRect>(r).y(), static_cast<QRect>(r).width(), static_cast<QRect>(r).height())); };
QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQLayout_TakeAt(this, this->objectName().toUtf8().data(), index)); };
void timerEvent(QTimerEvent * event) { callbackQLayout_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQLayout_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQLayout_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQLayout_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQLayout_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQLayout_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQLayout_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLayout_MetaObject(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data())); };
bool hasHeightForWidth() const { return callbackQLayout_HasHeightForWidth(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQLayout_HeightForWidth(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data(), w); };
int minimumHeightForWidth(int w) const { return callbackQLayout_MinimumHeightForWidth(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data(), w); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQLayout_SizeHint(const_cast<MyQLayout*>(this), this->objectName().toUtf8().data())); };
QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayout_SpacerItem(this, this->objectName().toUtf8().data())); };
QWidget * widget() { return static_cast<QWidget*>(callbackQLayout_Widget(this, this->objectName().toUtf8().data())); };
};
void QLayout_SetSizeConstraint(void* ptr, int vsi)
{
static_cast<QLayout*>(ptr)->setSizeConstraint(static_cast<QLayout::SizeConstraint>(vsi));
}
void QLayout_SetSpacing(void* ptr, int vin)
{
static_cast<QLayout*>(ptr)->setSpacing(vin);
}
int 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));
}
int 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 new QRect(static_cast<QRect>(static_cast<QLayout*>(ptr)->alignmentRect(*static_cast<QRect*>(r))).x(), static_cast<QRect>(static_cast<QLayout*>(ptr)->alignmentRect(*static_cast<QRect*>(r))).y(), static_cast<QRect>(static_cast<QLayout*>(ptr)->alignmentRect(*static_cast<QRect*>(r))).width(), static_cast<QRect>(static_cast<QLayout*>(ptr)->alignmentRect(*static_cast<QRect*>(r))).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 new QSize(static_cast<QSize>(QLayout::closestAcceptableSize(static_cast<QWidget*>(widget), *static_cast<QSize*>(size))).width(), static_cast<QSize>(QLayout::closestAcceptableSize(static_cast<QWidget*>(widget), *static_cast<QSize*>(size))).height());
}
void* QLayout_ContentsMargins(void* ptr)
{
return new QMargins(static_cast<QMargins>(static_cast<QLayout*>(ptr)->contentsMargins()).left(), static_cast<QMargins>(static_cast<QLayout*>(ptr)->contentsMargins()).top(), static_cast<QMargins>(static_cast<QLayout*>(ptr)->contentsMargins()).right(), static_cast<QMargins>(static_cast<QLayout*>(ptr)->contentsMargins()).bottom());
}
void* QLayout_ContentsRect(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QLayout*>(ptr)->contentsRect()).x(), static_cast<QRect>(static_cast<QLayout*>(ptr)->contentsRect()).y(), static_cast<QRect>(static_cast<QLayout*>(ptr)->contentsRect()).width(), static_cast<QRect>(static_cast<QLayout*>(ptr)->contentsRect()).height());
}
int QLayout_ControlTypes(void* ptr)
{
return static_cast<QLayout*>(ptr)->controlTypes();
}
int QLayout_ControlTypesDefault(void* ptr)
{
return static_cast<QLayout*>(ptr)->QLayout::controlTypes();
}
int QLayout_Count(void* ptr)
{
return static_cast<QLayout*>(ptr)->count();
}
int QLayout_ExpandingDirections(void* ptr)
{
return static_cast<QLayout*>(ptr)->expandingDirections();
}
int QLayout_ExpandingDirectionsDefault(void* ptr)
{
return static_cast<QLayout*>(ptr)->QLayout::expandingDirections();
}
void* QLayout_Geometry(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QLayout*>(ptr)->geometry()).x(), static_cast<QRect>(static_cast<QLayout*>(ptr)->geometry()).y(), static_cast<QRect>(static_cast<QLayout*>(ptr)->geometry()).width(), static_cast<QRect>(static_cast<QLayout*>(ptr)->geometry()).height());
}
void* QLayout_GeometryDefault(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QLayout*>(ptr)->QLayout::geometry()).x(), static_cast<QRect>(static_cast<QLayout*>(ptr)->QLayout::geometry()).y(), static_cast<QRect>(static_cast<QLayout*>(ptr)->QLayout::geometry()).width(), static_cast<QRect>(static_cast<QLayout*>(ptr)->QLayout::geometry()).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();
}
int QLayout_IsEmpty(void* ptr)
{
return static_cast<QLayout*>(ptr)->isEmpty();
}
int QLayout_IsEmptyDefault(void* ptr)
{
return static_cast<QLayout*>(ptr)->QLayout::isEmpty();
}
int 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 new QSize(static_cast<QSize>(static_cast<QLayout*>(ptr)->maximumSize()).width(), static_cast<QSize>(static_cast<QLayout*>(ptr)->maximumSize()).height());
}
void* QLayout_MaximumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QLayout*>(ptr)->QLayout::maximumSize()).width(), static_cast<QSize>(static_cast<QLayout*>(ptr)->QLayout::maximumSize()).height());
}
void* QLayout_MenuBar(void* ptr)
{
return static_cast<QLayout*>(ptr)->menuBar();
}
void* QLayout_MinimumSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QLayout*>(ptr)->minimumSize()).width(), static_cast<QSize>(static_cast<QLayout*>(ptr)->minimumSize()).height());
}
void* QLayout_MinimumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QLayout*>(ptr)->QLayout::minimumSize()).width(), static_cast<QSize>(static_cast<QLayout*>(ptr)->QLayout::minimumSize()).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, int options)
{
return static_cast<QLayout*>(ptr)->replaceWidget(static_cast<QWidget*>(from), static_cast<QWidget*>(to), static_cast<Qt::FindChildOption>(options));
}
int QLayout_SetAlignment2(void* ptr, void* l, int alignment)
{
return static_cast<QLayout*>(ptr)->setAlignment(static_cast<QLayout*>(l), static_cast<Qt::AlignmentFlag>(alignment));
}
int QLayout_SetAlignment(void* ptr, void* w, int 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, int 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));
}
int QLayout_Event(void* ptr, void* e)
{
return static_cast<QLayout*>(ptr)->event(static_cast<QEvent*>(e));
}
int QLayout_EventDefault(void* ptr, void* e)
{
return static_cast<QLayout*>(ptr)->QLayout::event(static_cast<QEvent*>(e));
}
int QLayout_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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());
}
int QLayout_HasHeightForWidth(void* ptr)
{
return static_cast<QLayout*>(ptr)->hasHeightForWidth();
}
int 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 new QSize(static_cast<QSize>(static_cast<QLayout*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QLayout*>(ptr)->sizeHint()).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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQLayoutItem(Qt::Alignment alignment) : QLayoutItem(alignment) {};
QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQLayoutItem_ControlTypes(const_cast<MyQLayoutItem*>(this), this->objectNameAbs().toUtf8().data())); };
Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQLayoutItem_ExpandingDirections(const_cast<MyQLayoutItem*>(this), this->objectNameAbs().toUtf8().data())); };
QRect geometry() const { return *static_cast<QRect*>(callbackQLayoutItem_Geometry(const_cast<MyQLayoutItem*>(this), this->objectNameAbs().toUtf8().data())); };
bool hasHeightForWidth() const { return callbackQLayoutItem_HasHeightForWidth(const_cast<MyQLayoutItem*>(this), this->objectNameAbs().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQLayoutItem_HeightForWidth(const_cast<MyQLayoutItem*>(this), this->objectNameAbs().toUtf8().data(), w); };
void invalidate() { callbackQLayoutItem_Invalidate(this, this->objectNameAbs().toUtf8().data()); };
bool isEmpty() const { return callbackQLayoutItem_IsEmpty(const_cast<MyQLayoutItem*>(this), this->objectNameAbs().toUtf8().data()) != 0; };
QLayout * layout() { return static_cast<QLayout*>(callbackQLayoutItem_Layout(this, this->objectNameAbs().toUtf8().data())); };
QSize maximumSize() const { return *static_cast<QSize*>(callbackQLayoutItem_MaximumSize(const_cast<MyQLayoutItem*>(this), this->objectNameAbs().toUtf8().data())); };
int minimumHeightForWidth(int w) const { return callbackQLayoutItem_MinimumHeightForWidth(const_cast<MyQLayoutItem*>(this), this->objectNameAbs().toUtf8().data(), w); };
QSize minimumSize() const { return *static_cast<QSize*>(callbackQLayoutItem_MinimumSize(const_cast<MyQLayoutItem*>(this), this->objectNameAbs().toUtf8().data())); };
void setGeometry(const QRect & r) { callbackQLayoutItem_SetGeometry(this, this->objectNameAbs().toUtf8().data(), new QRect(static_cast<QRect>(r).x(), static_cast<QRect>(r).y(), static_cast<QRect>(r).width(), static_cast<QRect>(r).height())); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQLayoutItem_SizeHint(const_cast<MyQLayoutItem*>(this), this->objectNameAbs().toUtf8().data())); };
QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQLayoutItem_SpacerItem(this, this->objectNameAbs().toUtf8().data())); };
QWidget * widget() { return static_cast<QWidget*>(callbackQLayoutItem_Widget(this, this->objectNameAbs().toUtf8().data())); };
};
void* QLayoutItem_NewQLayoutItem(int alignment)
{
return new MyQLayoutItem(static_cast<Qt::AlignmentFlag>(alignment));
}
int QLayoutItem_Alignment(void* ptr)
{
return static_cast<QLayoutItem*>(ptr)->alignment();
}
int QLayoutItem_ControlTypes(void* ptr)
{
return static_cast<QLayoutItem*>(ptr)->controlTypes();
}
int QLayoutItem_ControlTypesDefault(void* ptr)
{
return static_cast<QLayoutItem*>(ptr)->QLayoutItem::controlTypes();
}
int QLayoutItem_ExpandingDirections(void* ptr)
{
return static_cast<QLayoutItem*>(ptr)->expandingDirections();
}
void* QLayoutItem_Geometry(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QLayoutItem*>(ptr)->geometry()).x(), static_cast<QRect>(static_cast<QLayoutItem*>(ptr)->geometry()).y(), static_cast<QRect>(static_cast<QLayoutItem*>(ptr)->geometry()).width(), static_cast<QRect>(static_cast<QLayoutItem*>(ptr)->geometry()).height());
}
int QLayoutItem_HasHeightForWidth(void* ptr)
{
return static_cast<QLayoutItem*>(ptr)->hasHeightForWidth();
}
int 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();
}
int 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 new QSize(static_cast<QSize>(static_cast<QLayoutItem*>(ptr)->maximumSize()).width(), static_cast<QSize>(static_cast<QLayoutItem*>(ptr)->maximumSize()).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 new QSize(static_cast<QSize>(static_cast<QLayoutItem*>(ptr)->minimumSize()).width(), static_cast<QSize>(static_cast<QLayoutItem*>(ptr)->minimumSize()).height());
}
void QLayoutItem_SetAlignment(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QLayoutItem*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QLayoutItem*>(ptr)->sizeHint()).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();
}
char* QLayoutItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQLayoutItem*>(static_cast<QLayoutItem*>(ptr))) {
return static_cast<MyQLayoutItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QLayoutItem_BASE").toUtf8().data();
}
void QLayoutItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQLayoutItem*>(static_cast<QLayoutItem*>(ptr))) {
static_cast<MyQLayoutItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
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, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void changeEvent(QEvent * ev) { callbackQLineEdit_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void clear() { callbackQLineEdit_Clear(this, this->objectName().toUtf8().data()); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQLineEdit_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
void copy() const { callbackQLineEdit_Copy(const_cast<MyQLineEdit*>(this), this->objectName().toUtf8().data()); };
void Signal_CursorPositionChanged(int old, int n) { callbackQLineEdit_CursorPositionChanged(this, this->objectName().toUtf8().data(), old, n); };
void cut() { callbackQLineEdit_Cut(this, this->objectName().toUtf8().data()); };
void dragEnterEvent(QDragEnterEvent * e) { callbackQLineEdit_DragEnterEvent(this, this->objectName().toUtf8().data(), e); };
void dragLeaveEvent(QDragLeaveEvent * e) { callbackQLineEdit_DragLeaveEvent(this, this->objectName().toUtf8().data(), e); };
void dragMoveEvent(QDragMoveEvent * e) { callbackQLineEdit_DragMoveEvent(this, this->objectName().toUtf8().data(), e); };
void dropEvent(QDropEvent * e) { callbackQLineEdit_DropEvent(this, this->objectName().toUtf8().data(), e); };
void Signal_EditingFinished() { callbackQLineEdit_EditingFinished(this, this->objectName().toUtf8().data()); };
void focusInEvent(QFocusEvent * e) { callbackQLineEdit_FocusInEvent(this, this->objectName().toUtf8().data(), e); };
void focusOutEvent(QFocusEvent * e) { callbackQLineEdit_FocusOutEvent(this, this->objectName().toUtf8().data(), e); };
void inputMethodEvent(QInputMethodEvent * e) { callbackQLineEdit_InputMethodEvent(this, this->objectName().toUtf8().data(), e); };
QVariant inputMethodQuery(Qt::InputMethodQuery property) const { return *static_cast<QVariant*>(callbackQLineEdit_InputMethodQuery(const_cast<MyQLineEdit*>(this), this->objectName().toUtf8().data(), property)); };
void keyPressEvent(QKeyEvent * event) { callbackQLineEdit_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQLineEdit_MinimumSizeHint(const_cast<MyQLineEdit*>(this), this->objectName().toUtf8().data())); };
void mouseDoubleClickEvent(QMouseEvent * e) { callbackQLineEdit_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), e); };
void mouseMoveEvent(QMouseEvent * e) { callbackQLineEdit_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQLineEdit_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQLineEdit_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void paintEvent(QPaintEvent * vqp) { callbackQLineEdit_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
void paste() { callbackQLineEdit_Paste(this, this->objectName().toUtf8().data()); };
void redo() { callbackQLineEdit_Redo(this, this->objectName().toUtf8().data()); };
void Signal_ReturnPressed() { callbackQLineEdit_ReturnPressed(this, this->objectName().toUtf8().data()); };
void selectAll() { callbackQLineEdit_SelectAll(this, this->objectName().toUtf8().data()); };
void Signal_SelectionChanged() { callbackQLineEdit_SelectionChanged(this, this->objectName().toUtf8().data()); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQLineEdit_SizeHint(const_cast<MyQLineEdit*>(this), this->objectName().toUtf8().data())); };
void Signal_TextChanged(const QString & text) { callbackQLineEdit_TextChanged(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void Signal_TextEdited(const QString & text) { callbackQLineEdit_TextEdited(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void undo() { callbackQLineEdit_Undo(this, this->objectName().toUtf8().data()); };
void actionEvent(QActionEvent * event) { callbackQLineEdit_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQLineEdit_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQLineEdit_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQLineEdit_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQLineEdit_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQLineEdit_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQLineEdit_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQLineEdit_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQLineEdit_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQLineEdit_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQLineEdit_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQLineEdit_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQLineEdit_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQLineEdit_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQLineEdit_HasHeightForWidth(const_cast<MyQLineEdit*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQLineEdit_HeightForWidth(const_cast<MyQLineEdit*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQLineEdit_Hide(this, this->objectName().toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * event) { callbackQLineEdit_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQLineEdit_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQLineEdit_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQLineEdit_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQLineEdit_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQLineEdit_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQLineEdit_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQLineEdit_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQLineEdit_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQLineEdit_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQLineEdit_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQLineEdit_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQLineEdit_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQLineEdit_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQLineEdit_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQLineEdit_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQLineEdit_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQLineEdit_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQLineEdit_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQLineEdit_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQLineEdit_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQLineEdit_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQLineEdit_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQLineEdit_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQLineEdit_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQLineEdit_MetaObject(const_cast<MyQLineEdit*>(this), this->objectName().toUtf8().data())); };
};
int QLineEdit_Alignment(void* ptr)
{
return static_cast<QLineEdit*>(ptr)->alignment();
}
int 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 static_cast<QLineEdit*>(ptr)->displayText().toUtf8().data();
}
int QLineEdit_DragEnabled(void* ptr)
{
return static_cast<QLineEdit*>(ptr)->dragEnabled();
}
int QLineEdit_EchoMode(void* ptr)
{
return static_cast<QLineEdit*>(ptr)->echoMode();
}
int QLineEdit_HasAcceptableInput(void* ptr)
{
return static_cast<QLineEdit*>(ptr)->hasAcceptableInput();
}
int QLineEdit_HasFrame(void* ptr)
{
return static_cast<QLineEdit*>(ptr)->hasFrame();
}
int QLineEdit_HasSelectedText(void* ptr)
{
return static_cast<QLineEdit*>(ptr)->hasSelectedText();
}
char* QLineEdit_InputMask(void* ptr)
{
return static_cast<QLineEdit*>(ptr)->inputMask().toUtf8().data();
}
int QLineEdit_IsClearButtonEnabled(void* ptr)
{
return static_cast<QLineEdit*>(ptr)->isClearButtonEnabled();
}
int QLineEdit_IsModified(void* ptr)
{
return static_cast<QLineEdit*>(ptr)->isModified();
}
int QLineEdit_IsReadOnly(void* ptr)
{
return static_cast<QLineEdit*>(ptr)->isReadOnly();
}
int QLineEdit_IsRedoAvailable(void* ptr)
{
return static_cast<QLineEdit*>(ptr)->isRedoAvailable();
}
int 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 static_cast<QLineEdit*>(ptr)->placeholderText().toUtf8().data();
}
char* QLineEdit_SelectedText(void* ptr)
{
return static_cast<QLineEdit*>(ptr)->selectedText().toUtf8().data();
}
void QLineEdit_SetAlignment(void* ptr, int flag)
{
static_cast<QLineEdit*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(flag));
}
void QLineEdit_SetClearButtonEnabled(void* ptr, int enable)
{
static_cast<QLineEdit*>(ptr)->setClearButtonEnabled(enable != 0);
}
void QLineEdit_SetCursorMoveStyle(void* ptr, int 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, int b)
{
static_cast<QLineEdit*>(ptr)->setDragEnabled(b != 0);
}
void QLineEdit_SetEchoMode(void* ptr, int vec)
{
static_cast<QLineEdit*>(ptr)->setEchoMode(static_cast<QLineEdit::EchoMode>(vec));
}
void QLineEdit_SetFrame(void* ptr, int 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, int 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, int 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 static_cast<QLineEdit*>(ptr)->text().toUtf8().data();
}
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, int position)
{
return static_cast<QLineEdit*>(ptr)->addAction(*static_cast<QIcon*>(icon), static_cast<QLineEdit::ActionPosition>(position));
}
void QLineEdit_AddAction(void* ptr, void* action, int 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, int mark, int steps)
{
static_cast<QLineEdit*>(ptr)->cursorBackward(mark != 0, steps);
}
void QLineEdit_CursorForward(void* ptr, int 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 new QRect(static_cast<QRect>(static_cast<QLineEdit*>(ptr)->cursorRect()).x(), static_cast<QRect>(static_cast<QLineEdit*>(ptr)->cursorRect()).y(), static_cast<QRect>(static_cast<QLineEdit*>(ptr)->cursorRect()).width(), static_cast<QRect>(static_cast<QLineEdit*>(ptr)->cursorRect()).height());
}
void QLineEdit_CursorWordBackward(void* ptr, int mark)
{
static_cast<QLineEdit*>(ptr)->cursorWordBackward(mark != 0);
}
void QLineEdit_CursorWordForward(void* ptr, int 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, int mark)
{
static_cast<QLineEdit*>(ptr)->end(mark != 0);
}
int 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, int 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, int property)
{
return new QVariant(static_cast<QLineEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(property)));
}
void* QLineEdit_InputMethodQueryDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QLineEdit*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QLineEdit*>(ptr)->minimumSizeHint()).height());
}
void* QLineEdit_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QLineEdit*>(ptr)->QLineEdit::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QLineEdit*>(ptr)->QLineEdit::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QLineEdit*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QLineEdit*>(ptr)->sizeHint()).height());
}
void* QLineEdit_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QLineEdit*>(ptr)->QLineEdit::sizeHint()).width(), static_cast<QSize>(static_cast<QLineEdit*>(ptr)->QLineEdit::sizeHint()).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 new QMargins(static_cast<QMargins>(static_cast<QLineEdit*>(ptr)->textMargins()).left(), static_cast<QMargins>(static_cast<QLineEdit*>(ptr)->textMargins()).top(), static_cast<QMargins>(static_cast<QLineEdit*>(ptr)->textMargins()).right(), static_cast<QMargins>(static_cast<QLineEdit*>(ptr)->textMargins()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QLineEdit_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QLineEdit_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QLineEdit*>(ptr)->QLineEdit::setVisible(visible != 0);
}
void QLineEdit_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QLineEdit_SetWindowModifiedDefault(void* ptr, int 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));
}
int QLineEdit_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QLineEdit_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QLineEdit*>(ptr)->focusNextPrevChild(next != 0);
}
int QLineEdit_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QLineEdit*>(ptr)->QLineEdit::focusNextPrevChild(next != 0);
}
int QLineEdit_HasHeightForWidth(void* ptr)
{
return static_cast<QLineEdit*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QLineEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QLineEdit*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QLineEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QLineEdit*>(ptr)->QLineEdit::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QLineEdit_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QLineEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QLineEdit_SetHiddenDefault(void* ptr, int 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));
}
int QLineEdit_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QLineEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), new QModelIndex(current), new QModelIndex(previous)); };
void dragLeaveEvent(QDragLeaveEvent * e) { callbackQListView_DragLeaveEvent(this, this->objectName().toUtf8().data(), e); };
void dragMoveEvent(QDragMoveEvent * e) { callbackQListView_DragMoveEvent(this, this->objectName().toUtf8().data(), e); };
void dropEvent(QDropEvent * e) { callbackQListView_DropEvent(this, this->objectName().toUtf8().data(), e); };
int horizontalOffset() const { return callbackQListView_HorizontalOffset(const_cast<MyQListView*>(this), this->objectName().toUtf8().data()); };
QModelIndex indexAt(const QPoint & p) const { return *static_cast<QModelIndex*>(callbackQListView_IndexAt(const_cast<MyQListView*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(p).x(), static_cast<QPoint>(p).y()))); };
bool isIndexHidden(const QModelIndex & index) const { return callbackQListView_IsIndexHidden(const_cast<MyQListView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index)) != 0; };
void mouseMoveEvent(QMouseEvent * e) { callbackQListView_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQListView_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQListView_MoveCursor(this, this->objectName().toUtf8().data(), cursorAction, modifiers)); };
void paintEvent(QPaintEvent * e) { callbackQListView_PaintEvent(this, this->objectName().toUtf8().data(), e); };
void resizeEvent(QResizeEvent * e) { callbackQListView_ResizeEvent(this, this->objectName().toUtf8().data(), e); };
void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQListView_RowsAboutToBeRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQListView_RowsInserted(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQListView_ScrollTo(this, this->objectName().toUtf8().data(), new QModelIndex(index), hint); };
void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQListView_SelectionChanged(this, this->objectName().toUtf8().data(), new QItemSelection(selected), new QItemSelection(deselected)); };
void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQListView_SetSelection(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), command); };
void startDrag(Qt::DropActions supportedActions) { callbackQListView_StartDrag(this, this->objectName().toUtf8().data(), supportedActions); };
void updateGeometries() { callbackQListView_UpdateGeometries(this, this->objectName().toUtf8().data()); };
int verticalOffset() const { return callbackQListView_VerticalOffset(const_cast<MyQListView*>(this), this->objectName().toUtf8().data()); };
QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQListView_ViewOptions(const_cast<MyQListView*>(this), this->objectName().toUtf8().data())); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQListView_ViewportSizeHint(const_cast<MyQListView*>(this), this->objectName().toUtf8().data())); };
QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQListView_VisualRect(const_cast<MyQListView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index))); };
QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQListView_VisualRegionForSelection(const_cast<MyQListView*>(this), this->objectName().toUtf8().data(), new QItemSelection(selection))); };
void wheelEvent(QWheelEvent * e) { callbackQListView_WheelEvent(this, this->objectName().toUtf8().data(), e); };
bool viewportEvent(QEvent * event) { return callbackQListView_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
void clearSelection() { callbackQListView_ClearSelection(this, this->objectName().toUtf8().data()); };
void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQListView_CloseEditor(this, this->objectName().toUtf8().data(), editor, hint); };
void commitData(QWidget * editor) { callbackQListView_CommitData(this, this->objectName().toUtf8().data(), editor); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQListView_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void edit(const QModelIndex & index) { callbackQListView_Edit(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQListView_Edit2(this, this->objectName().toUtf8().data(), new QModelIndex(index), trigger, event) != 0; };
void editorDestroyed(QObject * editor) { callbackQListView_EditorDestroyed(this, this->objectName().toUtf8().data(), editor); };
void focusInEvent(QFocusEvent * event) { callbackQListView_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQListView_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * event) { callbackQListView_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQListView_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQListView_InputMethodQuery(const_cast<MyQListView*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQListView_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyboardSearch(const QString & search) { callbackQListView_KeyboardSearch(this, this->objectName().toUtf8().data(), search.toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQListView_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQListView_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void reset() { callbackQListView_Reset(this, this->objectName().toUtf8().data()); };
void scrollToBottom() { callbackQListView_ScrollToBottom(this, this->objectName().toUtf8().data()); };
void scrollToTop() { callbackQListView_ScrollToTop(this, this->objectName().toUtf8().data()); };
void selectAll() { callbackQListView_SelectAll(this, this->objectName().toUtf8().data()); };
QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQListView_SelectionCommand(const_cast<MyQListView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index), const_cast<QEvent*>(event))); };
void setCurrentIndex(const QModelIndex & index) { callbackQListView_SetCurrentIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setModel(QAbstractItemModel * model) { callbackQListView_SetModel(this, this->objectName().toUtf8().data(), model); };
void setRootIndex(const QModelIndex & index) { callbackQListView_SetRootIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQListView_SetSelectionModel(this, this->objectName().toUtf8().data(), selectionModel); };
int sizeHintForColumn(int column) const { return callbackQListView_SizeHintForColumn(const_cast<MyQListView*>(this), this->objectName().toUtf8().data(), column); };
int sizeHintForRow(int row) const { return callbackQListView_SizeHintForRow(const_cast<MyQListView*>(this), this->objectName().toUtf8().data(), row); };
void update(const QModelIndex & index) { callbackQListView_Update(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQListView_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQListView_MinimumSizeHint(const_cast<MyQListView*>(this), this->objectName().toUtf8().data())); };
void scrollContentsBy(int dx, int dy) { callbackQListView_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void setupViewport(QWidget * viewport) { callbackQListView_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQListView_SizeHint(const_cast<MyQListView*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * ev) { callbackQListView_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQListView_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQListView_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQListView_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQListView_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQListView_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQListView_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQListView_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQListView_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQListView_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQListView_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQListView_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQListView_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQListView_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQListView_HasHeightForWidth(const_cast<MyQListView*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQListView_HeightForWidth(const_cast<MyQListView*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQListView_Hide(this, this->objectName().toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * event) { callbackQListView_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQListView_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQListView_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQListView_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQListView_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQListView_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQListView_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQListView_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQListView_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQListView_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQListView_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQListView_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQListView_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQListView_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void updateMicroFocus() { callbackQListView_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQListView_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQListView_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQListView_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQListView_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQListView_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQListView_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQListView_MetaObject(const_cast<MyQListView*>(this), this->objectName().toUtf8().data())); };
};
int QListView_BatchSize(void* ptr)
{
return static_cast<QListView*>(ptr)->batchSize();
}
int QListView_Flow(void* ptr)
{
return static_cast<QListView*>(ptr)->flow();
}
void* QListView_GridSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QListView*>(ptr)->gridSize()).width(), static_cast<QSize>(static_cast<QListView*>(ptr)->gridSize()).height());
}
int QListView_IsSelectionRectVisible(void* ptr)
{
return static_cast<QListView*>(ptr)->isSelectionRectVisible();
}
int QListView_IsWrapping(void* ptr)
{
return static_cast<QListView*>(ptr)->isWrapping();
}
int QListView_LayoutMode(void* ptr)
{
return static_cast<QListView*>(ptr)->layoutMode();
}
int QListView_ModelColumn(void* ptr)
{
return static_cast<QListView*>(ptr)->modelColumn();
}
int QListView_Movement(void* ptr)
{
return static_cast<QListView*>(ptr)->movement();
}
int 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, int 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, int 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, int movement)
{
static_cast<QListView*>(ptr)->setMovement(static_cast<QListView::Movement>(movement));
}
void QListView_SetResizeMode(void* ptr, int mode)
{
static_cast<QListView*>(ptr)->setResizeMode(static_cast<QListView::ResizeMode>(mode));
}
void QListView_SetSelectionRectVisible(void* ptr, int 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, int enable)
{
static_cast<QListView*>(ptr)->setUniformItemSizes(enable != 0);
}
void QListView_SetViewMode(void* ptr, int mode)
{
static_cast<QListView*>(ptr)->setViewMode(static_cast<QListView::ViewMode>(mode));
}
void QListView_SetWordWrap(void* ptr, int on)
{
static_cast<QListView*>(ptr)->setWordWrap(on != 0);
}
void QListView_SetWrapping(void* ptr, int enable)
{
static_cast<QListView*>(ptr)->setWrapping(enable != 0);
}
int QListView_Spacing(void* ptr)
{
return static_cast<QListView*>(ptr)->spacing();
}
int QListView_UniformItemSizes(void* ptr)
{
return static_cast<QListView*>(ptr)->uniformItemSizes();
}
int QListView_ViewMode(void* ptr)
{
return static_cast<QListView*>(ptr)->viewMode();
}
int 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));
}
int 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)));
}
int QListView_IsIndexHidden(void* ptr, void* index)
{
return static_cast<QListView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}
int QListView_IsIndexHiddenDefault(void* ptr, void* index)
{
return static_cast<QListView*>(ptr)->QListView::isIndexHidden(*static_cast<QModelIndex*>(index));
}
int 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, int cursorAction, int modifiers)
{
return new QModelIndex(static_cast<QListView*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}
void* QListView_MoveCursorDefault(void* ptr, int cursorAction, int 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 new QRect(static_cast<QRect>(static_cast<QListView*>(ptr)->rectForIndex(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QListView*>(ptr)->rectForIndex(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QListView*>(ptr)->rectForIndex(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QListView*>(ptr)->rectForIndex(*static_cast<QModelIndex*>(index))).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, int hint)
{
static_cast<QListView*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}
void QListView_ScrollToDefault(void* ptr, void* index, int 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, int hide)
{
static_cast<QListView*>(ptr)->setRowHidden(row, hide != 0);
}
void QListView_SetSelection(void* ptr, void* rect, int command)
{
static_cast<QListView*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QListView_SetSelectionDefault(void* ptr, void* rect, int command)
{
static_cast<QListView*>(ptr)->QListView::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QListView_StartDrag(void* ptr, int supportedActions)
{
static_cast<QListView*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}
void QListView_StartDragDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QListView*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QListView*>(ptr)->viewportSizeHint()).height());
}
void* QListView_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QListView*>(ptr)->QListView::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QListView*>(ptr)->QListView::viewportSizeHint()).height());
}
void* QListView_VisualRect(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QListView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QListView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QListView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QListView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).height());
}
void* QListView_VisualRectDefault(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QListView*>(ptr)->QListView::visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QListView*>(ptr)->QListView::visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QListView*>(ptr)->QListView::visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QListView*>(ptr)->QListView::visualRect(*static_cast<QModelIndex*>(index))).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();
}
int QListView_ViewportEvent(void* ptr, void* event)
{
return static_cast<QListView*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int 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, int 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, int 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));
}
int QListView_Edit2(void* ptr, void* index, int trigger, void* event)
{
return static_cast<QListView*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}
int QListView_Edit2Default(void* ptr, void* index, int 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));
}
int QListView_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QListView*>(ptr)->focusNextPrevChild(next != 0);
}
int QListView_FocusNextPrevChildDefault(void* ptr, int 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, int query)
{
return new QVariant(static_cast<QListView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QListView_InputMethodQueryDefault(void* ptr, int 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();
}
int QListView_SelectionCommand(void* ptr, void* index, void* event)
{
return static_cast<QListView*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}
int 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 new QSize(static_cast<QSize>(static_cast<QListView*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QListView*>(ptr)->minimumSizeHint()).height());
}
void* QListView_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QListView*>(ptr)->QListView::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QListView*>(ptr)->QListView::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QListView*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QListView*>(ptr)->sizeHint()).height());
}
void* QListView_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QListView*>(ptr)->QListView::sizeHint()).width(), static_cast<QSize>(static_cast<QListView*>(ptr)->QListView::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QListView_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QListView_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QListView*>(ptr)->QListView::setVisible(visible != 0);
}
void QListView_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QListView_SetWindowModifiedDefault(void* ptr, int 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));
}
int QListView_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QListView_HasHeightForWidth(void* ptr)
{
return static_cast<QListView*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QListView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QListView*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QListView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QListView*>(ptr)->QListView::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QListView_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QListView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QListView_SetHiddenDefault(void* ptr, int 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));
}
int QListView_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QListView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data()); };
void Signal_CurrentItemChanged(QListWidgetItem * current, QListWidgetItem * previous) { callbackQListWidget_CurrentItemChanged(this, this->objectName().toUtf8().data(), current, previous); };
void Signal_CurrentRowChanged(int currentRow) { callbackQListWidget_CurrentRowChanged(this, this->objectName().toUtf8().data(), currentRow); };
void Signal_CurrentTextChanged(const QString & currentText) { callbackQListWidget_CurrentTextChanged(this, this->objectName().toUtf8().data(), currentText.toUtf8().data()); };
void dropEvent(QDropEvent * event) { callbackQListWidget_DropEvent(this, this->objectName().toUtf8().data(), event); };
bool dropMimeData(int index, const QMimeData * data, Qt::DropAction action) { return callbackQListWidget_DropMimeData(this, this->objectName().toUtf8().data(), index, const_cast<QMimeData*>(data), action) != 0; };
void Signal_ItemActivated(QListWidgetItem * item) { callbackQListWidget_ItemActivated(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemChanged(QListWidgetItem * item) { callbackQListWidget_ItemChanged(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemClicked(QListWidgetItem * item) { callbackQListWidget_ItemClicked(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemDoubleClicked(QListWidgetItem * item) { callbackQListWidget_ItemDoubleClicked(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemEntered(QListWidgetItem * item) { callbackQListWidget_ItemEntered(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemPressed(QListWidgetItem * item) { callbackQListWidget_ItemPressed(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemSelectionChanged() { callbackQListWidget_ItemSelectionChanged(this, this->objectName().toUtf8().data()); };
QStringList mimeTypes() const { return QString(callbackQListWidget_MimeTypes(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data())).split("|", QString::SkipEmptyParts); };
void scrollToItem(const QListWidgetItem * item, QAbstractItemView::ScrollHint hint) { callbackQListWidget_ScrollToItem(this, this->objectName().toUtf8().data(), const_cast<QListWidgetItem*>(item), hint); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQListWidget_SupportedDropActions(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data())); };
void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQListWidget_CurrentChanged(this, this->objectName().toUtf8().data(), new QModelIndex(current), new QModelIndex(previous)); };
void dragLeaveEvent(QDragLeaveEvent * e) { callbackQListWidget_DragLeaveEvent(this, this->objectName().toUtf8().data(), e); };
void dragMoveEvent(QDragMoveEvent * e) { callbackQListWidget_DragMoveEvent(this, this->objectName().toUtf8().data(), e); };
int horizontalOffset() const { return callbackQListWidget_HorizontalOffset(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data()); };
QModelIndex indexAt(const QPoint & p) const { return *static_cast<QModelIndex*>(callbackQListWidget_IndexAt(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(p).x(), static_cast<QPoint>(p).y()))); };
bool isIndexHidden(const QModelIndex & index) const { return callbackQListWidget_IsIndexHidden(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data(), new QModelIndex(index)) != 0; };
void mouseMoveEvent(QMouseEvent * e) { callbackQListWidget_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQListWidget_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQListWidget_MoveCursor(this, this->objectName().toUtf8().data(), cursorAction, modifiers)); };
void paintEvent(QPaintEvent * e) { callbackQListWidget_PaintEvent(this, this->objectName().toUtf8().data(), e); };
void resizeEvent(QResizeEvent * e) { callbackQListWidget_ResizeEvent(this, this->objectName().toUtf8().data(), e); };
void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQListWidget_RowsAboutToBeRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQListWidget_RowsInserted(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQListWidget_ScrollTo(this, this->objectName().toUtf8().data(), new QModelIndex(index), hint); };
void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQListWidget_SelectionChanged(this, this->objectName().toUtf8().data(), new QItemSelection(selected), new QItemSelection(deselected)); };
void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQListWidget_SetSelection(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), command); };
void startDrag(Qt::DropActions supportedActions) { callbackQListWidget_StartDrag(this, this->objectName().toUtf8().data(), supportedActions); };
void updateGeometries() { callbackQListWidget_UpdateGeometries(this, this->objectName().toUtf8().data()); };
int verticalOffset() const { return callbackQListWidget_VerticalOffset(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data()); };
QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQListWidget_ViewOptions(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data())); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQListWidget_ViewportSizeHint(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data())); };
QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQListWidget_VisualRect(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data(), new QModelIndex(index))); };
QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQListWidget_VisualRegionForSelection(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data(), new QItemSelection(selection))); };
void wheelEvent(QWheelEvent * e) { callbackQListWidget_WheelEvent(this, this->objectName().toUtf8().data(), e); };
bool viewportEvent(QEvent * event) { return callbackQListWidget_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
void clearSelection() { callbackQListWidget_ClearSelection(this, this->objectName().toUtf8().data()); };
void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQListWidget_CloseEditor(this, this->objectName().toUtf8().data(), editor, hint); };
void commitData(QWidget * editor) { callbackQListWidget_CommitData(this, this->objectName().toUtf8().data(), editor); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQListWidget_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void edit(const QModelIndex & index) { callbackQListWidget_Edit(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQListWidget_Edit2(this, this->objectName().toUtf8().data(), new QModelIndex(index), trigger, event) != 0; };
void editorDestroyed(QObject * editor) { callbackQListWidget_EditorDestroyed(this, this->objectName().toUtf8().data(), editor); };
void focusInEvent(QFocusEvent * event) { callbackQListWidget_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQListWidget_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * event) { callbackQListWidget_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQListWidget_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQListWidget_InputMethodQuery(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQListWidget_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyboardSearch(const QString & search) { callbackQListWidget_KeyboardSearch(this, this->objectName().toUtf8().data(), search.toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQListWidget_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQListWidget_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void reset() { callbackQListWidget_Reset(this, this->objectName().toUtf8().data()); };
void scrollToBottom() { callbackQListWidget_ScrollToBottom(this, this->objectName().toUtf8().data()); };
void scrollToTop() { callbackQListWidget_ScrollToTop(this, this->objectName().toUtf8().data()); };
void selectAll() { callbackQListWidget_SelectAll(this, this->objectName().toUtf8().data()); };
QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQListWidget_SelectionCommand(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data(), new QModelIndex(index), const_cast<QEvent*>(event))); };
void setCurrentIndex(const QModelIndex & index) { callbackQListWidget_SetCurrentIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setModel(QAbstractItemModel * model) { callbackQListWidget_SetModel(this, this->objectName().toUtf8().data(), model); };
void setRootIndex(const QModelIndex & index) { callbackQListWidget_SetRootIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQListWidget_SetSelectionModel(this, this->objectName().toUtf8().data(), selectionModel); };
int sizeHintForColumn(int column) const { return callbackQListWidget_SizeHintForColumn(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data(), column); };
int sizeHintForRow(int row) const { return callbackQListWidget_SizeHintForRow(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data(), row); };
void update(const QModelIndex & index) { callbackQListWidget_Update(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQListWidget_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQListWidget_MinimumSizeHint(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data())); };
void scrollContentsBy(int dx, int dy) { callbackQListWidget_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void setupViewport(QWidget * viewport) { callbackQListWidget_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQListWidget_SizeHint(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * ev) { callbackQListWidget_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQListWidget_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQListWidget_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQListWidget_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQListWidget_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQListWidget_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQListWidget_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQListWidget_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQListWidget_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQListWidget_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQListWidget_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQListWidget_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQListWidget_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQListWidget_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQListWidget_HasHeightForWidth(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQListWidget_HeightForWidth(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQListWidget_Hide(this, this->objectName().toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * event) { callbackQListWidget_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQListWidget_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQListWidget_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQListWidget_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQListWidget_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQListWidget_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQListWidget_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQListWidget_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQListWidget_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQListWidget_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQListWidget_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQListWidget_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQListWidget_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQListWidget_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void updateMicroFocus() { callbackQListWidget_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQListWidget_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQListWidget_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQListWidget_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQListWidget_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQListWidget_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQListWidget_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQListWidget_MetaObject(const_cast<MyQListWidget*>(this), this->objectName().toUtf8().data())); };
};
int QListWidget_Count(void* ptr)
{
return static_cast<QListWidget*>(ptr)->count();
}
int QListWidget_CurrentRow(void* ptr)
{
return static_cast<QListWidget*>(ptr)->currentRow();
}
int 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, int 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));
}
int QListWidget_DropMimeData(void* ptr, int index, void* data, int action)
{
return static_cast<QListWidget*>(ptr)->dropMimeData(index, static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action));
}
int QListWidget_DropMimeDataDefault(void* ptr, int index, void* data, int 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));
}
int 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 static_cast<QListWidget*>(ptr)->mimeTypes().join("|").toUtf8().data();
}
char* QListWidget_MimeTypesDefault(void* ptr)
{
return static_cast<QListWidget*>(ptr)->QListWidget::mimeTypes().join("|").toUtf8().data();
}
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, int 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, int command)
{
static_cast<QListWidget*>(ptr)->setCurrentItem(static_cast<QListWidgetItem*>(item), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QListWidget_SetCurrentRow2(void* ptr, int row, int 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_SortItems(void* ptr, int order)
{
static_cast<QListWidget*>(ptr)->sortItems(static_cast<Qt::SortOrder>(order));
}
int QListWidget_SupportedDropActions(void* ptr)
{
return static_cast<QListWidget*>(ptr)->supportedDropActions();
}
int 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 new QRect(static_cast<QRect>(static_cast<QListWidget*>(ptr)->visualItemRect(static_cast<QListWidgetItem*>(item))).x(), static_cast<QRect>(static_cast<QListWidget*>(ptr)->visualItemRect(static_cast<QListWidgetItem*>(item))).y(), static_cast<QRect>(static_cast<QListWidget*>(ptr)->visualItemRect(static_cast<QListWidgetItem*>(item))).width(), static_cast<QRect>(static_cast<QListWidget*>(ptr)->visualItemRect(static_cast<QListWidgetItem*>(item))).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)));
}
int QListWidget_IsIndexHidden(void* ptr, void* index)
{
return static_cast<QListWidget*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}
int 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, int cursorAction, int modifiers)
{
return new QModelIndex(static_cast<QListWidget*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}
void* QListWidget_MoveCursorDefault(void* ptr, int cursorAction, int 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, int hint)
{
static_cast<QListWidget*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}
void QListWidget_ScrollToDefault(void* ptr, void* index, int 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, int command)
{
static_cast<QListWidget*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QListWidget_SetSelectionDefault(void* ptr, void* rect, int command)
{
static_cast<QListWidget*>(ptr)->QListWidget::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QListWidget_StartDrag(void* ptr, int supportedActions)
{
static_cast<QListWidget*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}
void QListWidget_StartDragDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QListWidget*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QListWidget*>(ptr)->viewportSizeHint()).height());
}
void* QListWidget_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QListWidget*>(ptr)->QListWidget::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QListWidget*>(ptr)->QListWidget::viewportSizeHint()).height());
}
void* QListWidget_VisualRect(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QListWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QListWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QListWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QListWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).height());
}
void* QListWidget_VisualRectDefault(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QListWidget*>(ptr)->QListWidget::visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QListWidget*>(ptr)->QListWidget::visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QListWidget*>(ptr)->QListWidget::visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QListWidget*>(ptr)->QListWidget::visualRect(*static_cast<QModelIndex*>(index))).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));
}
int QListWidget_ViewportEvent(void* ptr, void* event)
{
return static_cast<QListWidget*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int 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, int 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, int 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));
}
int QListWidget_Edit2(void* ptr, void* index, int trigger, void* event)
{
return static_cast<QListWidget*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}
int QListWidget_Edit2Default(void* ptr, void* index, int 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));
}
int QListWidget_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QListWidget*>(ptr)->focusNextPrevChild(next != 0);
}
int QListWidget_FocusNextPrevChildDefault(void* ptr, int 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, int query)
{
return new QVariant(static_cast<QListWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QListWidget_InputMethodQueryDefault(void* ptr, int 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();
}
int QListWidget_SelectionCommand(void* ptr, void* index, void* event)
{
return static_cast<QListWidget*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}
int 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));
}
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));
}
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 new QSize(static_cast<QSize>(static_cast<QListWidget*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QListWidget*>(ptr)->minimumSizeHint()).height());
}
void* QListWidget_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QListWidget*>(ptr)->QListWidget::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QListWidget*>(ptr)->QListWidget::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QListWidget*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QListWidget*>(ptr)->sizeHint()).height());
}
void* QListWidget_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QListWidget*>(ptr)->QListWidget::sizeHint()).width(), static_cast<QSize>(static_cast<QListWidget*>(ptr)->QListWidget::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QListWidget_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QListWidget_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QListWidget*>(ptr)->QListWidget::setVisible(visible != 0);
}
void QListWidget_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QListWidget_SetWindowModifiedDefault(void* ptr, int 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));
}
int QListWidget_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QListWidget_HasHeightForWidth(void* ptr)
{
return static_cast<QListWidget*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QListWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QListWidget*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QListWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QListWidget*>(ptr)->QListWidget::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QListWidget_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QListWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QListWidget_SetHiddenDefault(void* ptr, int 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));
}
int QListWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QListWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
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), this->objectNameAbs().toUtf8().data())); };
QVariant data(int role) const { return *static_cast<QVariant*>(callbackQListWidgetItem_Data(const_cast<MyQListWidgetItem*>(this), this->objectNameAbs().toUtf8().data(), role)); };
void setData(int role, const QVariant & value) { callbackQListWidgetItem_SetData(this, this->objectNameAbs().toUtf8().data(), role, new QVariant(value)); };
};
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, int 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());
}
int 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));
}
int 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());
}
int QListWidgetItem_IsHidden(void* ptr)
{
return static_cast<QListWidgetItem*>(ptr)->isHidden();
}
int 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, int 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, int 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, int 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 new QSize(static_cast<QSize>(static_cast<QListWidgetItem*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QListWidgetItem*>(ptr)->sizeHint()).height());
}
char* QListWidgetItem_StatusTip(void* ptr)
{
return static_cast<QListWidgetItem*>(ptr)->statusTip().toUtf8().data();
}
char* QListWidgetItem_Text(void* ptr)
{
return static_cast<QListWidgetItem*>(ptr)->text().toUtf8().data();
}
int QListWidgetItem_TextAlignment(void* ptr)
{
return static_cast<QListWidgetItem*>(ptr)->textAlignment();
}
char* QListWidgetItem_ToolTip(void* ptr)
{
return static_cast<QListWidgetItem*>(ptr)->toolTip().toUtf8().data();
}
int QListWidgetItem_Type(void* ptr)
{
return static_cast<QListWidgetItem*>(ptr)->type();
}
char* QListWidgetItem_WhatsThis(void* ptr)
{
return static_cast<QListWidgetItem*>(ptr)->whatsThis().toUtf8().data();
}
void QListWidgetItem_DestroyQListWidgetItem(void* ptr)
{
static_cast<QListWidgetItem*>(ptr)->~QListWidgetItem();
}
char* QListWidgetItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQListWidgetItem*>(static_cast<QListWidgetItem*>(ptr))) {
return static_cast<MyQListWidgetItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QListWidgetItem_BASE").toUtf8().data();
}
void QListWidgetItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQListWidgetItem*>(static_cast<QListWidgetItem*>(ptr))) {
static_cast<MyQListWidgetItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
class MyQMacCocoaViewContainer: public QMacCocoaViewContainer
{
public:
void actionEvent(QActionEvent * event) { callbackQMacCocoaViewContainer_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQMacCocoaViewContainer_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMacCocoaViewContainer_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQMacCocoaViewContainer_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQMacCocoaViewContainer_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQMacCocoaViewContainer_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQMacCocoaViewContainer_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQMacCocoaViewContainer_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQMacCocoaViewContainer_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQMacCocoaViewContainer_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMacCocoaViewContainer_MinimumSizeHint(const_cast<MyQMacCocoaViewContainer*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQMacCocoaViewContainer_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQMacCocoaViewContainer_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQMacCocoaViewContainer_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQMacCocoaViewContainer_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQMacCocoaViewContainer_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQMacCocoaViewContainer_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQMacCocoaViewContainer_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQMacCocoaViewContainer_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQMacCocoaViewContainer_SizeHint(const_cast<MyQMacCocoaViewContainer*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * event) { callbackQMacCocoaViewContainer_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQMacCocoaViewContainer_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQMacCocoaViewContainer_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQMacCocoaViewContainer_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQMacCocoaViewContainer_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQMacCocoaViewContainer_HasHeightForWidth(const_cast<MyQMacCocoaViewContainer*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQMacCocoaViewContainer_HeightForWidth(const_cast<MyQMacCocoaViewContainer*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQMacCocoaViewContainer_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQMacCocoaViewContainer_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMacCocoaViewContainer_InputMethodQuery(const_cast<MyQMacCocoaViewContainer*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQMacCocoaViewContainer_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQMacCocoaViewContainer_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQMacCocoaViewContainer_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQMacCocoaViewContainer_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQMacCocoaViewContainer_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQMacCocoaViewContainer_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQMacCocoaViewContainer_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMacCocoaViewContainer_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQMacCocoaViewContainer_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQMacCocoaViewContainer_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQMacCocoaViewContainer_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQMacCocoaViewContainer_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQMacCocoaViewContainer_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQMacCocoaViewContainer_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQMacCocoaViewContainer_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQMacCocoaViewContainer_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQMacCocoaViewContainer_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQMacCocoaViewContainer_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQMacCocoaViewContainer_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQMacCocoaViewContainer_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQMacCocoaViewContainer_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQMacCocoaViewContainer_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQMacCocoaViewContainer_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQMacCocoaViewContainer_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQMacCocoaViewContainer_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQMacCocoaViewContainer_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQMacCocoaViewContainer_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQMacCocoaViewContainer_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQMacCocoaViewContainer_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQMacCocoaViewContainer_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMacCocoaViewContainer_MetaObject(const_cast<MyQMacCocoaViewContainer*>(this), this->objectName().toUtf8().data())); };
};
void QMacCocoaViewContainer_DestroyQMacCocoaViewContainer(void* ptr)
{
static_cast<QMacCocoaViewContainer*>(ptr)->~QMacCocoaViewContainer();
}
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 new QSize(static_cast<QSize>(static_cast<QMacCocoaViewContainer*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMacCocoaViewContainer*>(ptr)->minimumSizeHint()).height());
}
void* QMacCocoaViewContainer_MinimumSizeHintDefault(void* ptr)
{
#ifdef Q_OS_OSX
return new QSize(static_cast<QSize>(static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QMacCocoaViewContainer_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QMacCocoaViewContainer_SetVisibleDefault(void* ptr, int visible)
{
#ifdef Q_OS_OSX
static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::setVisible(visible != 0);
#endif
}
void QMacCocoaViewContainer_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QMacCocoaViewContainer_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QMacCocoaViewContainer*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QMacCocoaViewContainer*>(ptr)->sizeHint()).height());
}
void* QMacCocoaViewContainer_SizeHintDefault(void* ptr)
{
#ifdef Q_OS_OSX
return new QSize(static_cast<QSize>(static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::sizeHint()).width(), static_cast<QSize>(static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::sizeHint()).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
}
int QMacCocoaViewContainer_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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
}
int QMacCocoaViewContainer_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QMacCocoaViewContainer*>(ptr)->focusNextPrevChild(next != 0);
}
int QMacCocoaViewContainer_FocusNextPrevChildDefault(void* ptr, int next)
{
#ifdef Q_OS_OSX
return static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::focusNextPrevChild(next != 0);
#else
return false;
#endif
}
int QMacCocoaViewContainer_HasHeightForWidth(void* ptr)
{
return static_cast<QMacCocoaViewContainer*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QMacCocoaViewContainer*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QMacCocoaViewContainer_InputMethodQueryDefault(void* ptr, int 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
}
int QMacCocoaViewContainer_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMacCocoaViewContainer*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QMacCocoaViewContainer_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
#ifdef Q_OS_OSX
return static_cast<QMacCocoaViewContainer*>(ptr)->QMacCocoaViewContainer::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QMacCocoaViewContainer_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QMacCocoaViewContainer*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QMacCocoaViewContainer_SetHiddenDefault(void* ptr, int 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
}
int QMacCocoaViewContainer_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QMacCocoaViewContainer*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQMacNativeWidget_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQMacNativeWidget_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMacNativeWidget_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQMacNativeWidget_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQMacNativeWidget_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQMacNativeWidget_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQMacNativeWidget_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQMacNativeWidget_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQMacNativeWidget_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQMacNativeWidget_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMacNativeWidget_MinimumSizeHint(const_cast<MyQMacNativeWidget*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQMacNativeWidget_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQMacNativeWidget_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQMacNativeWidget_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQMacNativeWidget_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQMacNativeWidget_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQMacNativeWidget_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQMacNativeWidget_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQMacNativeWidget_ShowEvent(this, this->objectName().toUtf8().data(), event); };
void changeEvent(QEvent * event) { callbackQMacNativeWidget_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQMacNativeWidget_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQMacNativeWidget_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQMacNativeWidget_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQMacNativeWidget_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQMacNativeWidget_HasHeightForWidth(const_cast<MyQMacNativeWidget*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQMacNativeWidget_HeightForWidth(const_cast<MyQMacNativeWidget*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQMacNativeWidget_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQMacNativeWidget_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMacNativeWidget_InputMethodQuery(const_cast<MyQMacNativeWidget*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQMacNativeWidget_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQMacNativeWidget_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQMacNativeWidget_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQMacNativeWidget_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQMacNativeWidget_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQMacNativeWidget_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQMacNativeWidget_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMacNativeWidget_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQMacNativeWidget_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQMacNativeWidget_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQMacNativeWidget_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQMacNativeWidget_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQMacNativeWidget_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQMacNativeWidget_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQMacNativeWidget_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQMacNativeWidget_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQMacNativeWidget_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQMacNativeWidget_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQMacNativeWidget_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQMacNativeWidget_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQMacNativeWidget_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQMacNativeWidget_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQMacNativeWidget_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQMacNativeWidget_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQMacNativeWidget_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQMacNativeWidget_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQMacNativeWidget_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQMacNativeWidget_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQMacNativeWidget_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQMacNativeWidget_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMacNativeWidget_MetaObject(const_cast<MyQMacNativeWidget*>(this), this->objectName().toUtf8().data())); };
};
int QMacNativeWidget_Event(void* ptr, void* ev)
{
return static_cast<QMacNativeWidget*>(ptr)->event(static_cast<QEvent*>(ev));
}
void* QMacNativeWidget_SizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMacNativeWidget*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QMacNativeWidget*>(ptr)->sizeHint()).height());
}
void* QMacNativeWidget_SizeHintDefault(void* ptr)
{
#ifdef Q_OS_OSX
return new QSize(static_cast<QSize>(static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::sizeHint()).width(), static_cast<QSize>(static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::sizeHint()).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 new QSize(static_cast<QSize>(static_cast<QMacNativeWidget*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMacNativeWidget*>(ptr)->minimumSizeHint()).height());
}
void* QMacNativeWidget_MinimumSizeHintDefault(void* ptr)
{
#ifdef Q_OS_OSX
return new QSize(static_cast<QSize>(static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QMacNativeWidget_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QMacNativeWidget_SetVisibleDefault(void* ptr, int visible)
{
#ifdef Q_OS_OSX
static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::setVisible(visible != 0);
#endif
}
void QMacNativeWidget_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QMacNativeWidget_SetWindowModifiedDefault(void* ptr, int 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
}
int QMacNativeWidget_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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
}
int QMacNativeWidget_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QMacNativeWidget*>(ptr)->focusNextPrevChild(next != 0);
}
int QMacNativeWidget_FocusNextPrevChildDefault(void* ptr, int next)
{
#ifdef Q_OS_OSX
return static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::focusNextPrevChild(next != 0);
#else
return false;
#endif
}
int QMacNativeWidget_HasHeightForWidth(void* ptr)
{
return static_cast<QMacNativeWidget*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QMacNativeWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QMacNativeWidget_InputMethodQueryDefault(void* ptr, int 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
}
int QMacNativeWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMacNativeWidget*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QMacNativeWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
#ifdef Q_OS_OSX
return static_cast<QMacNativeWidget*>(ptr)->QMacNativeWidget::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QMacNativeWidget_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QMacNativeWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QMacNativeWidget_SetHiddenDefault(void* ptr, int 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
}
int QMacNativeWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QMacNativeWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), enabled); };
void setDockNestingEnabled(bool enabled) { callbackQMainWindow_SetDockNestingEnabled(this, this->objectName().toUtf8().data(), enabled); };
void setUnifiedTitleAndToolBarOnMac(bool set) { callbackQMainWindow_SetUnifiedTitleAndToolBarOnMac(this, this->objectName().toUtf8().data(), set); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQMainWindow_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
QMenu * createPopupMenu() { return static_cast<QMenu*>(callbackQMainWindow_CreatePopupMenu(this, this->objectName().toUtf8().data())); };
void Signal_IconSizeChanged(const QSize & iconSize) { callbackQMainWindow_IconSizeChanged(this, this->objectName().toUtf8().data(), new QSize(static_cast<QSize>(iconSize).width(), static_cast<QSize>(iconSize).height())); };
void Signal_ToolButtonStyleChanged(Qt::ToolButtonStyle toolButtonStyle) { callbackQMainWindow_ToolButtonStyleChanged(this, this->objectName().toUtf8().data(), toolButtonStyle); };
void actionEvent(QActionEvent * event) { callbackQMainWindow_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQMainWindow_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMainWindow_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQMainWindow_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQMainWindow_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQMainWindow_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQMainWindow_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQMainWindow_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQMainWindow_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQMainWindow_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMainWindow_MinimumSizeHint(const_cast<MyQMainWindow*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQMainWindow_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQMainWindow_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQMainWindow_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQMainWindow_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQMainWindow_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQMainWindow_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQMainWindow_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQMainWindow_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQMainWindow_SizeHint(const_cast<MyQMainWindow*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * event) { callbackQMainWindow_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQMainWindow_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQMainWindow_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQMainWindow_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQMainWindow_HasHeightForWidth(const_cast<MyQMainWindow*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQMainWindow_HeightForWidth(const_cast<MyQMainWindow*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQMainWindow_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQMainWindow_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMainWindow_InputMethodQuery(const_cast<MyQMainWindow*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQMainWindow_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQMainWindow_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQMainWindow_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQMainWindow_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQMainWindow_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQMainWindow_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQMainWindow_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMainWindow_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQMainWindow_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQMainWindow_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQMainWindow_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQMainWindow_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQMainWindow_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQMainWindow_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQMainWindow_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQMainWindow_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQMainWindow_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQMainWindow_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQMainWindow_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQMainWindow_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQMainWindow_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQMainWindow_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQMainWindow_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQMainWindow_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQMainWindow_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQMainWindow_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQMainWindow_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQMainWindow_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQMainWindow_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQMainWindow_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMainWindow_MetaObject(const_cast<MyQMainWindow*>(this), this->objectName().toUtf8().data())); };
};
int QMainWindow_DockOptions(void* ptr)
{
return static_cast<QMainWindow*>(ptr)->dockOptions();
}
int QMainWindow_DocumentMode(void* ptr)
{
return static_cast<QMainWindow*>(ptr)->documentMode();
}
void* QMainWindow_IconSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMainWindow*>(ptr)->iconSize()).width(), static_cast<QSize>(static_cast<QMainWindow*>(ptr)->iconSize()).height());
}
int QMainWindow_IsAnimated(void* ptr)
{
return static_cast<QMainWindow*>(ptr)->isAnimated();
}
int QMainWindow_IsDockNestingEnabled(void* ptr)
{
return static_cast<QMainWindow*>(ptr)->isDockNestingEnabled();
}
void QMainWindow_SetAnimated(void* ptr, int enabled)
{
QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setAnimated", Q_ARG(bool, enabled != 0));
}
void QMainWindow_SetDockNestingEnabled(void* ptr, int enabled)
{
QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setDockNestingEnabled", Q_ARG(bool, enabled != 0));
}
void QMainWindow_SetDockOptions(void* ptr, int options)
{
static_cast<QMainWindow*>(ptr)->setDockOptions(static_cast<QMainWindow::DockOption>(options));
}
void QMainWindow_SetDocumentMode(void* ptr, int 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, int tabShape)
{
static_cast<QMainWindow*>(ptr)->setTabShape(static_cast<QTabWidget::TabShape>(tabShape));
}
void QMainWindow_SetToolButtonStyle(void* ptr, int toolButtonStyle)
{
static_cast<QMainWindow*>(ptr)->setToolButtonStyle(static_cast<Qt::ToolButtonStyle>(toolButtonStyle));
}
void QMainWindow_SetUnifiedTitleAndToolBarOnMac(void* ptr, int set)
{
QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setUnifiedTitleAndToolBarOnMac", Q_ARG(bool, set != 0));
}
void QMainWindow_SplitDockWidget(void* ptr, void* first, void* second, int orientation)
{
static_cast<QMainWindow*>(ptr)->splitDockWidget(static_cast<QDockWidget*>(first), static_cast<QDockWidget*>(second), static_cast<Qt::Orientation>(orientation));
}
int 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));
}
int QMainWindow_ToolButtonStyle(void* ptr)
{
return static_cast<QMainWindow*>(ptr)->toolButtonStyle();
}
int QMainWindow_UnifiedTitleAndToolBarOnMac(void* ptr)
{
return static_cast<QMainWindow*>(ptr)->unifiedTitleAndToolBarOnMac();
}
void* QMainWindow_NewQMainWindow(void* parent, int flags)
{
return new MyQMainWindow(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(flags));
}
void QMainWindow_AddDockWidget(void* ptr, int area, void* dockwidget)
{
static_cast<QMainWindow*>(ptr)->addDockWidget(static_cast<Qt::DockWidgetArea>(area), static_cast<QDockWidget*>(dockwidget));
}
void QMainWindow_AddDockWidget2(void* ptr, int area, void* dockwidget, int 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, int area, void* toolbar)
{
static_cast<QMainWindow*>(ptr)->addToolBar(static_cast<Qt::ToolBarArea>(area), static_cast<QToolBar*>(toolbar));
}
void QMainWindow_AddToolBarBreak(void* ptr, int 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));
}
int QMainWindow_Corner(void* ptr, int 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();
}
int QMainWindow_DockWidgetArea(void* ptr, void* dockwidget)
{
return static_cast<QMainWindow*>(ptr)->dockWidgetArea(static_cast<QDockWidget*>(dockwidget));
}
int 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));
}
int QMainWindow_RestoreDockWidget(void* ptr, void* dockwidget)
{
return static_cast<QMainWindow*>(ptr)->restoreDockWidget(static_cast<QDockWidget*>(dockwidget));
}
int QMainWindow_RestoreState(void* ptr, char* state, int version)
{
return static_cast<QMainWindow*>(ptr)->restoreState(QByteArray(state), version);
}
char* QMainWindow_SaveState(void* ptr, int version)
{
return QString(static_cast<QMainWindow*>(ptr)->saveState(version)).toUtf8().data();
}
void QMainWindow_SetCentralWidget(void* ptr, void* widget)
{
static_cast<QMainWindow*>(ptr)->setCentralWidget(static_cast<QWidget*>(widget));
}
void QMainWindow_SetCorner(void* ptr, int corner, int 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, int areas, int 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();
}
int QMainWindow_TabPosition(void* ptr, int area)
{
return static_cast<QMainWindow*>(ptr)->tabPosition(static_cast<Qt::DockWidgetArea>(area));
}
void* QMainWindow_TakeCentralWidget(void* ptr)
{
return static_cast<QMainWindow*>(ptr)->takeCentralWidget();
}
int QMainWindow_ToolBarArea(void* ptr, void* toolbar)
{
return static_cast<QMainWindow*>(ptr)->toolBarArea(static_cast<QToolBar*>(toolbar));
}
int 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, int 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 new QSize(static_cast<QSize>(static_cast<QMainWindow*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMainWindow*>(ptr)->minimumSizeHint()).height());
}
void* QMainWindow_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMainWindow*>(ptr)->QMainWindow::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMainWindow*>(ptr)->QMainWindow::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QMainWindow_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QMainWindow_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QMainWindow*>(ptr)->QMainWindow::setVisible(visible != 0);
}
void QMainWindow_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QMainWindow_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QMainWindow*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QMainWindow*>(ptr)->sizeHint()).height());
}
void* QMainWindow_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMainWindow*>(ptr)->QMainWindow::sizeHint()).width(), static_cast<QSize>(static_cast<QMainWindow*>(ptr)->QMainWindow::sizeHint()).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));
}
int QMainWindow_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QMainWindow_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QMainWindow*>(ptr)->focusNextPrevChild(next != 0);
}
int QMainWindow_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QMainWindow*>(ptr)->QMainWindow::focusNextPrevChild(next != 0);
}
int QMainWindow_HasHeightForWidth(void* ptr)
{
return static_cast<QMainWindow*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QMainWindow*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QMainWindow_InputMethodQueryDefault(void* ptr, int 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));
}
int QMainWindow_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMainWindow*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QMainWindow_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMainWindow*>(ptr)->QMainWindow::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QMainWindow_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QMainWindow*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QMainWindow_SetHiddenDefault(void* ptr, int 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));
}
int QMainWindow_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QMainWindow*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data()); };
void activatePreviousSubWindow() { callbackQMdiArea_ActivatePreviousSubWindow(this, this->objectName().toUtf8().data()); };
void cascadeSubWindows() { callbackQMdiArea_CascadeSubWindows(this, this->objectName().toUtf8().data()); };
void closeActiveSubWindow() { callbackQMdiArea_CloseActiveSubWindow(this, this->objectName().toUtf8().data()); };
void closeAllSubWindows() { callbackQMdiArea_CloseAllSubWindows(this, this->objectName().toUtf8().data()); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMdiArea_MinimumSizeHint(const_cast<MyQMdiArea*>(this), this->objectName().toUtf8().data())); };
void paintEvent(QPaintEvent * paintEvent) { callbackQMdiArea_PaintEvent(this, this->objectName().toUtf8().data(), paintEvent); };
void resizeEvent(QResizeEvent * resizeEvent) { callbackQMdiArea_ResizeEvent(this, this->objectName().toUtf8().data(), resizeEvent); };
void scrollContentsBy(int dx, int dy) { callbackQMdiArea_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void setActiveSubWindow(QMdiSubWindow * window) { callbackQMdiArea_SetActiveSubWindow(this, this->objectName().toUtf8().data(), window); };
void setupViewport(QWidget * viewport) { callbackQMdiArea_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
void showEvent(QShowEvent * showEvent) { callbackQMdiArea_ShowEvent(this, this->objectName().toUtf8().data(), showEvent); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQMdiArea_SizeHint(const_cast<MyQMdiArea*>(this), this->objectName().toUtf8().data())); };
void Signal_SubWindowActivated(QMdiSubWindow * window) { callbackQMdiArea_SubWindowActivated(this, this->objectName().toUtf8().data(), window); };
void tileSubWindows() { callbackQMdiArea_TileSubWindows(this, this->objectName().toUtf8().data()); };
bool viewportEvent(QEvent * event) { return callbackQMdiArea_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
void dragEnterEvent(QDragEnterEvent * event) { callbackQMdiArea_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMdiArea_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQMdiArea_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQMdiArea_DropEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQMdiArea_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
void keyPressEvent(QKeyEvent * e) { callbackQMdiArea_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseDoubleClickEvent(QMouseEvent * e) { callbackQMdiArea_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), e); };
void mouseMoveEvent(QMouseEvent * e) { callbackQMdiArea_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQMdiArea_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQMdiArea_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQMdiArea_ViewportSizeHint(const_cast<MyQMdiArea*>(this), this->objectName().toUtf8().data())); };
void wheelEvent(QWheelEvent * e) { callbackQMdiArea_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void changeEvent(QEvent * ev) { callbackQMdiArea_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQMdiArea_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQMdiArea_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQMdiArea_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQMdiArea_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQMdiArea_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQMdiArea_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQMdiArea_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQMdiArea_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQMdiArea_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQMdiArea_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQMdiArea_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQMdiArea_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQMdiArea_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQMdiArea_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQMdiArea_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQMdiArea_HasHeightForWidth(const_cast<MyQMdiArea*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQMdiArea_HeightForWidth(const_cast<MyQMdiArea*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQMdiArea_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQMdiArea_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMdiArea_InputMethodQuery(const_cast<MyQMdiArea*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQMdiArea_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQMdiArea_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMdiArea_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQMdiArea_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQMdiArea_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQMdiArea_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQMdiArea_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQMdiArea_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQMdiArea_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQMdiArea_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQMdiArea_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQMdiArea_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQMdiArea_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQMdiArea_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQMdiArea_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQMdiArea_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void connectNotify(const QMetaMethod & sign) { callbackQMdiArea_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQMdiArea_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQMdiArea_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQMdiArea_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMdiArea_MetaObject(const_cast<MyQMdiArea*>(this), this->objectName().toUtf8().data())); };
};
int QMdiArea_ActivationOrder(void* ptr)
{
return static_cast<QMdiArea*>(ptr)->activationOrder();
}
void* QMdiArea_Background(void* ptr)
{
return new QBrush(static_cast<QMdiArea*>(ptr)->background());
}
int QMdiArea_DocumentMode(void* ptr)
{
return static_cast<QMdiArea*>(ptr)->documentMode();
}
void QMdiArea_SetActivationOrder(void* ptr, int 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, int enabled)
{
static_cast<QMdiArea*>(ptr)->setDocumentMode(enabled != 0);
}
void QMdiArea_SetTabPosition(void* ptr, int position)
{
static_cast<QMdiArea*>(ptr)->setTabPosition(static_cast<QTabWidget::TabPosition>(position));
}
void QMdiArea_SetTabShape(void* ptr, int shape)
{
static_cast<QMdiArea*>(ptr)->setTabShape(static_cast<QTabWidget::TabShape>(shape));
}
void QMdiArea_SetTabsClosable(void* ptr, int closable)
{
static_cast<QMdiArea*>(ptr)->setTabsClosable(closable != 0);
}
void QMdiArea_SetTabsMovable(void* ptr, int movable)
{
static_cast<QMdiArea*>(ptr)->setTabsMovable(movable != 0);
}
void QMdiArea_SetViewMode(void* ptr, int mode)
{
static_cast<QMdiArea*>(ptr)->setViewMode(static_cast<QMdiArea::ViewMode>(mode));
}
int QMdiArea_TabPosition(void* ptr)
{
return static_cast<QMdiArea*>(ptr)->tabPosition();
}
int QMdiArea_TabShape(void* ptr)
{
return static_cast<QMdiArea*>(ptr)->tabShape();
}
int QMdiArea_TabsClosable(void* ptr)
{
return static_cast<QMdiArea*>(ptr)->tabsClosable();
}
int QMdiArea_TabsMovable(void* ptr)
{
return static_cast<QMdiArea*>(ptr)->tabsMovable();
}
int 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, int 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();
}
int QMdiArea_Event(void* ptr, void* event)
{
return static_cast<QMdiArea*>(ptr)->event(static_cast<QEvent*>(event));
}
int 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 new QSize(static_cast<QSize>(static_cast<QMdiArea*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMdiArea*>(ptr)->minimumSizeHint()).height());
}
void* QMdiArea_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMdiArea*>(ptr)->QMdiArea::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMdiArea*>(ptr)->QMdiArea::minimumSizeHint()).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, int option, int 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 new QSize(static_cast<QSize>(static_cast<QMdiArea*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QMdiArea*>(ptr)->sizeHint()).height());
}
void* QMdiArea_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMdiArea*>(ptr)->QMdiArea::sizeHint()).width(), static_cast<QSize>(static_cast<QMdiArea*>(ptr)->QMdiArea::sizeHint()).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));
}
int QMdiArea_TestOption(void* ptr, int 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));
}
int QMdiArea_ViewportEvent(void* ptr, void* event)
{
return static_cast<QMdiArea*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int 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 new QSize(static_cast<QSize>(static_cast<QMdiArea*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QMdiArea*>(ptr)->viewportSizeHint()).height());
}
void* QMdiArea_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMdiArea*>(ptr)->QMdiArea::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QMdiArea*>(ptr)->QMdiArea::viewportSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QMdiArea_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QMdiArea_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QMdiArea*>(ptr)->QMdiArea::setVisible(visible != 0);
}
void QMdiArea_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QMdiArea_SetWindowModifiedDefault(void* ptr, int 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));
}
int QMdiArea_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QMdiArea_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QMdiArea*>(ptr)->focusNextPrevChild(next != 0);
}
int QMdiArea_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QMdiArea*>(ptr)->QMdiArea::focusNextPrevChild(next != 0);
}
int QMdiArea_HasHeightForWidth(void* ptr)
{
return static_cast<QMdiArea*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QMdiArea*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QMdiArea_InputMethodQueryDefault(void* ptr, int 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();
}
int QMdiArea_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMdiArea*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QMdiArea_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMdiArea*>(ptr)->QMdiArea::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QMdiArea_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QMdiArea*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QMdiArea_SetHiddenDefault(void* ptr, int 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, this->objectName().toUtf8().data()); };
void changeEvent(QEvent * changeEvent) { callbackQMdiSubWindow_ChangeEvent(this, this->objectName().toUtf8().data(), changeEvent); };
void closeEvent(QCloseEvent * closeEvent) { callbackQMdiSubWindow_CloseEvent(this, this->objectName().toUtf8().data(), closeEvent); };
void contextMenuEvent(QContextMenuEvent * contextMenuEvent) { callbackQMdiSubWindow_ContextMenuEvent(this, this->objectName().toUtf8().data(), contextMenuEvent); };
void focusInEvent(QFocusEvent * focusInEvent) { callbackQMdiSubWindow_FocusInEvent(this, this->objectName().toUtf8().data(), focusInEvent); };
void focusOutEvent(QFocusEvent * focusOutEvent) { callbackQMdiSubWindow_FocusOutEvent(this, this->objectName().toUtf8().data(), focusOutEvent); };
void hideEvent(QHideEvent * hideEvent) { callbackQMdiSubWindow_HideEvent(this, this->objectName().toUtf8().data(), hideEvent); };
void keyPressEvent(QKeyEvent * keyEvent) { callbackQMdiSubWindow_KeyPressEvent(this, this->objectName().toUtf8().data(), keyEvent); };
void leaveEvent(QEvent * leaveEvent) { callbackQMdiSubWindow_LeaveEvent(this, this->objectName().toUtf8().data(), leaveEvent); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMdiSubWindow_MinimumSizeHint(const_cast<MyQMdiSubWindow*>(this), this->objectName().toUtf8().data())); };
void mouseDoubleClickEvent(QMouseEvent * mouseEvent) { callbackQMdiSubWindow_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), mouseEvent); };
void mouseMoveEvent(QMouseEvent * mouseEvent) { callbackQMdiSubWindow_MouseMoveEvent(this, this->objectName().toUtf8().data(), mouseEvent); };
void mousePressEvent(QMouseEvent * mouseEvent) { callbackQMdiSubWindow_MousePressEvent(this, this->objectName().toUtf8().data(), mouseEvent); };
void mouseReleaseEvent(QMouseEvent * mouseEvent) { callbackQMdiSubWindow_MouseReleaseEvent(this, this->objectName().toUtf8().data(), mouseEvent); };
void moveEvent(QMoveEvent * moveEvent) { callbackQMdiSubWindow_MoveEvent(this, this->objectName().toUtf8().data(), moveEvent); };
void paintEvent(QPaintEvent * paintEvent) { callbackQMdiSubWindow_PaintEvent(this, this->objectName().toUtf8().data(), paintEvent); };
void resizeEvent(QResizeEvent * resizeEvent) { callbackQMdiSubWindow_ResizeEvent(this, this->objectName().toUtf8().data(), resizeEvent); };
void showEvent(QShowEvent * showEvent) { callbackQMdiSubWindow_ShowEvent(this, this->objectName().toUtf8().data(), showEvent); };
void showShaded() { callbackQMdiSubWindow_ShowShaded(this, this->objectName().toUtf8().data()); };
void showSystemMenu() { callbackQMdiSubWindow_ShowSystemMenu(this, this->objectName().toUtf8().data()); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQMdiSubWindow_SizeHint(const_cast<MyQMdiSubWindow*>(this), this->objectName().toUtf8().data())); };
void Signal_WindowStateChanged(Qt::WindowStates oldState, Qt::WindowStates newState) { callbackQMdiSubWindow_WindowStateChanged(this, this->objectName().toUtf8().data(), oldState, newState); };
void actionEvent(QActionEvent * event) { callbackQMdiSubWindow_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQMdiSubWindow_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMdiSubWindow_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQMdiSubWindow_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQMdiSubWindow_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQMdiSubWindow_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQMdiSubWindow_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQMdiSubWindow_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQMdiSubWindow_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQMdiSubWindow_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQMdiSubWindow_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQMdiSubWindow_Close(this, this->objectName().toUtf8().data()) != 0; };
bool focusNextPrevChild(bool next) { return callbackQMdiSubWindow_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQMdiSubWindow_HasHeightForWidth(const_cast<MyQMdiSubWindow*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQMdiSubWindow_HeightForWidth(const_cast<MyQMdiSubWindow*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQMdiSubWindow_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQMdiSubWindow_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMdiSubWindow_InputMethodQuery(const_cast<MyQMdiSubWindow*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQMdiSubWindow_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQMdiSubWindow_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMdiSubWindow_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQMdiSubWindow_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQMdiSubWindow_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQMdiSubWindow_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQMdiSubWindow_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQMdiSubWindow_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQMdiSubWindow_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQMdiSubWindow_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQMdiSubWindow_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQMdiSubWindow_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQMdiSubWindow_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQMdiSubWindow_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQMdiSubWindow_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQMdiSubWindow_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQMdiSubWindow_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQMdiSubWindow_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQMdiSubWindow_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQMdiSubWindow_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQMdiSubWindow_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMdiSubWindow_MetaObject(const_cast<MyQMdiSubWindow*>(this), this->objectName().toUtf8().data())); };
};
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, int 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));
}
int QMdiSubWindow_Event(void* ptr, void* event)
{
return static_cast<QMdiSubWindow*>(ptr)->event(static_cast<QEvent*>(event));
}
int 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));
}
int 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 new QSize(static_cast<QSize>(static_cast<QMdiSubWindow*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMdiSubWindow*>(ptr)->minimumSizeHint()).height());
}
void* QMdiSubWindow_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::minimumSizeHint()).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, int option, int 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 new QSize(static_cast<QSize>(static_cast<QMdiSubWindow*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QMdiSubWindow*>(ptr)->sizeHint()).height());
}
void* QMdiSubWindow_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::sizeHint()).width(), static_cast<QSize>(static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::sizeHint()).height());
}
void* QMdiSubWindow_SystemMenu(void* ptr)
{
return static_cast<QMdiSubWindow*>(ptr)->systemMenu();
}
int QMdiSubWindow_TestOption(void* ptr, int 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, int oldState, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QMdiSubWindow_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QMdiSubWindow_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::setVisible(visible != 0);
}
void QMdiSubWindow_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QMdiSubWindow_SetWindowModifiedDefault(void* ptr, int 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));
}
int QMdiSubWindow_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QMdiSubWindow_CloseDefault(void* ptr)
{
return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::close();
}
int QMdiSubWindow_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QMdiSubWindow*>(ptr)->focusNextPrevChild(next != 0);
}
int QMdiSubWindow_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::focusNextPrevChild(next != 0);
}
int QMdiSubWindow_HasHeightForWidth(void* ptr)
{
return static_cast<QMdiSubWindow*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QMdiSubWindow*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QMdiSubWindow_InputMethodQueryDefault(void* ptr, int 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();
}
int QMdiSubWindow_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMdiSubWindow*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QMdiSubWindow_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMdiSubWindow*>(ptr)->QMdiSubWindow::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QMdiSubWindow_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QMdiSubWindow*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QMdiSubWindow_SetHiddenDefault(void* ptr, int 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, this->objectName().toUtf8().data()); };
void Signal_AboutToShow() { callbackQMenu_AboutToShow(this, this->objectName().toUtf8().data()); };
void actionEvent(QActionEvent * e) { callbackQMenu_ActionEvent(this, this->objectName().toUtf8().data(), e); };
void changeEvent(QEvent * e) { callbackQMenu_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void enterEvent(QEvent * vqe) { callbackQMenu_EnterEvent(this, this->objectName().toUtf8().data(), vqe); };
bool focusNextPrevChild(bool next) { return callbackQMenu_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void hideEvent(QHideEvent * vqh) { callbackQMenu_HideEvent(this, this->objectName().toUtf8().data(), vqh); };
void Signal_Hovered(QAction * action) { callbackQMenu_Hovered(this, this->objectName().toUtf8().data(), action); };
void keyPressEvent(QKeyEvent * e) { callbackQMenu_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void leaveEvent(QEvent * vqe) { callbackQMenu_LeaveEvent(this, this->objectName().toUtf8().data(), vqe); };
void mouseMoveEvent(QMouseEvent * e) { callbackQMenu_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQMenu_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQMenu_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void paintEvent(QPaintEvent * e) { callbackQMenu_PaintEvent(this, this->objectName().toUtf8().data(), e); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQMenu_SizeHint(const_cast<MyQMenu*>(this), this->objectName().toUtf8().data())); };
void Signal_Triggered(QAction * action) { callbackQMenu_Triggered(this, this->objectName().toUtf8().data(), action); };
void wheelEvent(QWheelEvent * e) { callbackQMenu_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQMenu_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMenu_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQMenu_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQMenu_DropEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQMenu_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQMenu_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMenu_MinimumSizeHint(const_cast<MyQMenu*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQMenu_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQMenu_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQMenu_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQMenu_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQMenu_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQMenu_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQMenu_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQMenu_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQMenu_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQMenu_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQMenu_HasHeightForWidth(const_cast<MyQMenu*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQMenu_HeightForWidth(const_cast<MyQMenu*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQMenu_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQMenu_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMenu_InputMethodQuery(const_cast<MyQMenu*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQMenu_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQMenu_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQMenu_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMenu_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQMenu_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQMenu_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQMenu_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQMenu_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQMenu_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQMenu_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQMenu_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQMenu_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQMenu_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQMenu_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQMenu_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQMenu_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQMenu_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQMenu_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQMenu_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQMenu_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQMenu_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQMenu_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQMenu_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQMenu_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMenu_MetaObject(const_cast<MyQMenu*>(this), this->objectName().toUtf8().data())); };
};
void* QMenu_Icon(void* ptr)
{
return new QIcon(static_cast<QMenu*>(ptr)->icon());
}
int QMenu_IsTearOffEnabled(void* ptr)
{
return static_cast<QMenu*>(ptr)->isTearOffEnabled();
}
int 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, int collapse)
{
static_cast<QMenu*>(ptr)->setSeparatorsCollapsible(collapse != 0);
}
void QMenu_SetTearOffEnabled(void* ptr, int 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, int visible)
{
static_cast<QMenu*>(ptr)->setToolTipsVisible(visible != 0);
}
char* QMenu_Title(void* ptr)
{
return static_cast<QMenu*>(ptr)->title().toUtf8().data();
}
int 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 new QRect(static_cast<QRect>(static_cast<QMenu*>(ptr)->actionGeometry(static_cast<QAction*>(act))).x(), static_cast<QRect>(static_cast<QMenu*>(ptr)->actionGeometry(static_cast<QAction*>(act))).y(), static_cast<QRect>(static_cast<QMenu*>(ptr)->actionGeometry(static_cast<QAction*>(act))).width(), static_cast<QRect>(static_cast<QMenu*>(ptr)->actionGeometry(static_cast<QAction*>(act))).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));
}
int 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));
}
int QMenu_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QMenu*>(ptr)->focusNextPrevChild(next != 0);
}
int QMenu_FocusNextPrevChildDefault(void* ptr, int 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));
}
int QMenu_IsEmpty(void* ptr)
{
return static_cast<QMenu*>(ptr)->isEmpty();
}
int 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_SetAsDockMenu(void* ptr)
{
#ifdef Q_OS_OSX
static_cast<QMenu*>(ptr)->setAsDockMenu();
#endif
}
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_SetDefaultAction(void* ptr, void* act)
{
static_cast<QMenu*>(ptr)->setDefaultAction(static_cast<QAction*>(act));
}
void* QMenu_SizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMenu*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QMenu*>(ptr)->sizeHint()).height());
}
void* QMenu_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMenu*>(ptr)->QMenu::sizeHint()).width(), static_cast<QSize>(static_cast<QMenu*>(ptr)->QMenu::sizeHint()).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 new QSize(static_cast<QSize>(static_cast<QMenu*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMenu*>(ptr)->minimumSizeHint()).height());
}
void* QMenu_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMenu*>(ptr)->QMenu::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMenu*>(ptr)->QMenu::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QMenu_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QMenu_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QMenu*>(ptr)->QMenu::setVisible(visible != 0);
}
void QMenu_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QMenu_SetWindowModifiedDefault(void* ptr, int 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));
}
int QMenu_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QMenu_HasHeightForWidth(void* ptr)
{
return static_cast<QMenu*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QMenu*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QMenu_InputMethodQueryDefault(void* ptr, int 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));
}
int QMenu_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMenu*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QMenu_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMenu*>(ptr)->QMenu::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QMenu_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QMenu*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QMenu_SetHiddenDefault(void* ptr, int 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));
}
int QMenu_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QMenu*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), e); };
void changeEvent(QEvent * e) { callbackQMenuBar_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void focusInEvent(QFocusEvent * vqf) { callbackQMenuBar_FocusInEvent(this, this->objectName().toUtf8().data(), vqf); };
void focusOutEvent(QFocusEvent * vqf) { callbackQMenuBar_FocusOutEvent(this, this->objectName().toUtf8().data(), vqf); };
int heightForWidth(int vin) const { return callbackQMenuBar_HeightForWidth(const_cast<MyQMenuBar*>(this), this->objectName().toUtf8().data(), vin); };
void Signal_Hovered(QAction * action) { callbackQMenuBar_Hovered(this, this->objectName().toUtf8().data(), action); };
void keyPressEvent(QKeyEvent * e) { callbackQMenuBar_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void leaveEvent(QEvent * vqe) { callbackQMenuBar_LeaveEvent(this, this->objectName().toUtf8().data(), vqe); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMenuBar_MinimumSizeHint(const_cast<MyQMenuBar*>(this), this->objectName().toUtf8().data())); };
void mouseMoveEvent(QMouseEvent * e) { callbackQMenuBar_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQMenuBar_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQMenuBar_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void paintEvent(QPaintEvent * e) { callbackQMenuBar_PaintEvent(this, this->objectName().toUtf8().data(), e); };
void resizeEvent(QResizeEvent * vqr) { callbackQMenuBar_ResizeEvent(this, this->objectName().toUtf8().data(), vqr); };
void setVisible(bool visible) { callbackQMenuBar_SetVisible(this, this->objectName().toUtf8().data(), visible); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQMenuBar_SizeHint(const_cast<MyQMenuBar*>(this), this->objectName().toUtf8().data())); };
void Signal_Triggered(QAction * action) { callbackQMenuBar_Triggered(this, this->objectName().toUtf8().data(), action); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQMenuBar_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMenuBar_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQMenuBar_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQMenuBar_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQMenuBar_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQMenuBar_HideEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQMenuBar_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQMenuBar_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQMenuBar_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setWindowModified(bool vbo) { callbackQMenuBar_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQMenuBar_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQMenuBar_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQMenuBar_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQMenuBar_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQMenuBar_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQMenuBar_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQMenuBar_HasHeightForWidth(const_cast<MyQMenuBar*>(this), this->objectName().toUtf8().data()) != 0; };
void hide() { callbackQMenuBar_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQMenuBar_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMenuBar_InputMethodQuery(const_cast<MyQMenuBar*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQMenuBar_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQMenuBar_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQMenuBar_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMenuBar_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQMenuBar_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQMenuBar_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQMenuBar_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQMenuBar_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQMenuBar_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQMenuBar_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQMenuBar_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQMenuBar_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQMenuBar_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQMenuBar_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQMenuBar_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQMenuBar_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQMenuBar_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQMenuBar_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQMenuBar_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQMenuBar_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQMenuBar_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQMenuBar_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQMenuBar_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMenuBar_MetaObject(const_cast<MyQMenuBar*>(this), this->objectName().toUtf8().data())); };
};
int QMenuBar_IsDefaultUp(void* ptr)
{
return static_cast<QMenuBar*>(ptr)->isDefaultUp();
}
int QMenuBar_IsNativeMenuBar(void* ptr)
{
return static_cast<QMenuBar*>(ptr)->isNativeMenuBar();
}
void QMenuBar_SetCornerWidget(void* ptr, void* widget, int corner)
{
static_cast<QMenuBar*>(ptr)->setCornerWidget(static_cast<QWidget*>(widget), static_cast<Qt::Corner>(corner));
}
void QMenuBar_SetDefaultUp(void* ptr, int vbo)
{
static_cast<QMenuBar*>(ptr)->setDefaultUp(vbo != 0);
}
void QMenuBar_SetNativeMenuBar(void* ptr, int 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 new QRect(static_cast<QRect>(static_cast<QMenuBar*>(ptr)->actionGeometry(static_cast<QAction*>(act))).x(), static_cast<QRect>(static_cast<QMenuBar*>(ptr)->actionGeometry(static_cast<QAction*>(act))).y(), static_cast<QRect>(static_cast<QMenuBar*>(ptr)->actionGeometry(static_cast<QAction*>(act))).width(), static_cast<QRect>(static_cast<QMenuBar*>(ptr)->actionGeometry(static_cast<QAction*>(act))).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, int 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
}
int QMenuBar_Event(void* ptr, void* e)
{
return static_cast<QMenuBar*>(ptr)->event(static_cast<QEvent*>(e));
}
int 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 new QSize(static_cast<QSize>(static_cast<QMenuBar*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMenuBar*>(ptr)->minimumSizeHint()).height());
}
void* QMenuBar_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMenuBar*>(ptr)->QMenuBar::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMenuBar*>(ptr)->QMenuBar::minimumSizeHint()).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, int visible)
{
QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QMenuBar_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QMenuBar*>(ptr)->QMenuBar::setVisible(visible != 0);
}
void* QMenuBar_SizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMenuBar*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QMenuBar*>(ptr)->sizeHint()).height());
}
void* QMenuBar_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMenuBar*>(ptr)->QMenuBar::sizeHint()).width(), static_cast<QSize>(static_cast<QMenuBar*>(ptr)->QMenuBar::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QMenuBar_SetEnabledDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QMenuBar_SetWindowModifiedDefault(void* ptr, int 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));
}
int QMenuBar_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QMenuBar_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QMenuBar*>(ptr)->focusNextPrevChild(next != 0);
}
int QMenuBar_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QMenuBar*>(ptr)->QMenuBar::focusNextPrevChild(next != 0);
}
int QMenuBar_HasHeightForWidth(void* ptr)
{
return static_cast<QMenuBar*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QMenuBar*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QMenuBar_InputMethodQueryDefault(void* ptr, int 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));
}
int QMenuBar_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMenuBar*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QMenuBar_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMenuBar*>(ptr)->QMenuBar::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QMenuBar_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QMenuBar*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QMenuBar_SetHiddenDefault(void* ptr, int 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, this->objectName().toUtf8().data(), button); };
void changeEvent(QEvent * ev) { callbackQMessageBox_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void closeEvent(QCloseEvent * e) { callbackQMessageBox_CloseEvent(this, this->objectName().toUtf8().data(), e); };
int exec() { return callbackQMessageBox_Exec(this, this->objectName().toUtf8().data()); };
void keyPressEvent(QKeyEvent * e) { callbackQMessageBox_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void resizeEvent(QResizeEvent * event) { callbackQMessageBox_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setVisible(bool visible) { callbackQMessageBox_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void showEvent(QShowEvent * e) { callbackQMessageBox_ShowEvent(this, this->objectName().toUtf8().data(), e); };
void accept() { callbackQMessageBox_Accept(this, this->objectName().toUtf8().data()); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQMessageBox_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
void done(int r) { callbackQMessageBox_Done(this, this->objectName().toUtf8().data(), r); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQMessageBox_MinimumSizeHint(const_cast<MyQMessageBox*>(this), this->objectName().toUtf8().data())); };
void reject() { callbackQMessageBox_Reject(this, this->objectName().toUtf8().data()); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQMessageBox_SizeHint(const_cast<MyQMessageBox*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQMessageBox_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQMessageBox_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQMessageBox_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQMessageBox_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQMessageBox_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQMessageBox_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQMessageBox_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQMessageBox_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQMessageBox_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQMessageBox_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQMessageBox_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQMessageBox_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQMessageBox_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQMessageBox_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setWindowModified(bool vbo) { callbackQMessageBox_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
bool close() { return callbackQMessageBox_Close(this, this->objectName().toUtf8().data()) != 0; };
bool focusNextPrevChild(bool next) { return callbackQMessageBox_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQMessageBox_HasHeightForWidth(const_cast<MyQMessageBox*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQMessageBox_HeightForWidth(const_cast<MyQMessageBox*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQMessageBox_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQMessageBox_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQMessageBox_InputMethodQuery(const_cast<MyQMessageBox*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQMessageBox_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQMessageBox_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQMessageBox_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQMessageBox_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQMessageBox_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQMessageBox_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQMessageBox_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQMessageBox_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQMessageBox_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQMessageBox_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQMessageBox_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQMessageBox_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQMessageBox_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQMessageBox_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQMessageBox_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQMessageBox_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQMessageBox_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQMessageBox_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQMessageBox_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQMessageBox_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQMessageBox_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQMessageBox_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQMessageBox_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQMessageBox_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQMessageBox_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQMessageBox_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQMessageBox_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMessageBox_MetaObject(const_cast<MyQMessageBox*>(this), this->objectName().toUtf8().data())); };
};
char* QMessageBox_DetailedText(void* ptr)
{
return static_cast<QMessageBox*>(ptr)->detailedText().toUtf8().data();
}
int 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 static_cast<QMessageBox*>(ptr)->informativeText().toUtf8().data();
}
void QMessageBox_SetDetailedText(void* ptr, char* text)
{
static_cast<QMessageBox*>(ptr)->setDetailedText(QString(text));
}
void QMessageBox_SetIcon(void* ptr, int 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, int 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, int format)
{
static_cast<QMessageBox*>(ptr)->setTextFormat(static_cast<Qt::TextFormat>(format));
}
void QMessageBox_SetTextInteractionFlags(void* ptr, int flags)
{
static_cast<QMessageBox*>(ptr)->setTextInteractionFlags(static_cast<Qt::TextInteractionFlag>(flags));
}
int QMessageBox_StandardButtons(void* ptr)
{
return static_cast<QMessageBox*>(ptr)->standardButtons();
}
char* QMessageBox_Text(void* ptr)
{
return static_cast<QMessageBox*>(ptr)->text().toUtf8().data();
}
int QMessageBox_TextFormat(void* ptr)
{
return static_cast<QMessageBox*>(ptr)->textFormat();
}
int QMessageBox_TextInteractionFlags(void* ptr)
{
return static_cast<QMessageBox*>(ptr)->textInteractionFlags();
}
void* QMessageBox_NewQMessageBox2(int icon, char* title, char* text, int buttons, void* parent, int 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, int button)
{
return static_cast<QMessageBox*>(ptr)->addButton(static_cast<QMessageBox::StandardButton>(button));
}
void* QMessageBox_AddButton2(void* ptr, char* text, int role)
{
return static_cast<QMessageBox*>(ptr)->addButton(QString(text), static_cast<QMessageBox::ButtonRole>(role));
}
void QMessageBox_AddButton(void* ptr, void* button, int role)
{
static_cast<QMessageBox*>(ptr)->addButton(static_cast<QAbstractButton*>(button), static_cast<QMessageBox::ButtonRole>(role));
}
void* QMessageBox_Button(void* ptr, int 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));
}
int 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));
}
int QMessageBox_QMessageBox_Critical(void* parent, char* title, char* text, int buttons, int 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();
}
int 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();
}
int QMessageBox_QMessageBox_Information(void* parent, char* title, char* text, int buttons, int 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));
}
int QMessageBox_QMessageBox_Question(void* parent, char* title, char* text, int buttons, int 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, int 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, int button)
{
static_cast<QMessageBox*>(ptr)->setEscapeButton(static_cast<QMessageBox::StandardButton>(button));
}
void QMessageBox_SetVisible(void* ptr, int visible)
{
static_cast<QMessageBox*>(ptr)->setVisible(visible != 0);
}
void QMessageBox_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QMessageBox*>(ptr)->QMessageBox::setVisible(visible != 0);
}
void QMessageBox_SetWindowModality(void* ptr, int 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));
}
int QMessageBox_StandardButton(void* ptr, void* button)
{
return static_cast<QMessageBox*>(ptr)->standardButton(static_cast<QAbstractButton*>(button));
}
int QMessageBox_QMessageBox_Warning(void* parent, char* title, char* text, int buttons, int 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 new QSize(static_cast<QSize>(static_cast<QMessageBox*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMessageBox*>(ptr)->minimumSizeHint()).height());
}
void* QMessageBox_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMessageBox*>(ptr)->QMessageBox::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QMessageBox*>(ptr)->QMessageBox::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QMessageBox*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QMessageBox*>(ptr)->sizeHint()).height());
}
void* QMessageBox_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QMessageBox*>(ptr)->QMessageBox::sizeHint()).width(), static_cast<QSize>(static_cast<QMessageBox*>(ptr)->QMessageBox::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QMessageBox_SetEnabledDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QMessageBox_SetWindowModifiedDefault(void* ptr, int vbo)
{
static_cast<QMessageBox*>(ptr)->QMessageBox::setWindowModified(vbo != 0);
}
int QMessageBox_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QMessageBox_CloseDefault(void* ptr)
{
return static_cast<QMessageBox*>(ptr)->QMessageBox::close();
}
int QMessageBox_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QMessageBox*>(ptr)->focusNextPrevChild(next != 0);
}
int QMessageBox_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QMessageBox*>(ptr)->QMessageBox::focusNextPrevChild(next != 0);
}
int QMessageBox_HasHeightForWidth(void* ptr)
{
return static_cast<QMessageBox*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QMessageBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QMessageBox_InputMethodQueryDefault(void* ptr, int 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));
}
int QMessageBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMessageBox*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QMessageBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QMessageBox*>(ptr)->QMessageBox::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QMessageBox_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QMessageBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QMessageBox_SetHiddenDefault(void* ptr, int 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, int ty, int 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));
}
int QMouseEventTransition_Button(void* ptr)
{
return static_cast<QMouseEventTransition*>(ptr)->button();
}
int 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());
}
int 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, int 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, int modifierMask)
{
static_cast<QMouseEventTransition*>(ptr)->setModifierMask(static_cast<Qt::KeyboardModifier>(modifierMask));
}
void QMouseEventTransition_DestroyQMouseEventTransition(void* ptr)
{
static_cast<QMouseEventTransition*>(ptr)->~QMouseEventTransition();
}
int QMouseEventTransition_Event(void* ptr, void* e)
{
return static_cast<QMouseEventTransition*>(ptr)->event(static_cast<QEvent*>(e));
}
int 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));
}
int QMouseEventTransition_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QMouseEventTransition*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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<double>(static_cast<QPanGesture*>(ptr)->acceleration());
}
void* QPanGesture_Delta(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QPanGesture*>(ptr)->delta()).x(), static_cast<QPointF>(static_cast<QPanGesture*>(ptr)->delta()).y());
}
void* QPanGesture_LastOffset(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QPanGesture*>(ptr)->lastOffset()).x(), static_cast<QPointF>(static_cast<QPanGesture*>(ptr)->lastOffset()).y());
}
void* QPanGesture_Offset(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QPanGesture*>(ptr)->offset()).x(), static_cast<QPointF>(static_cast<QPanGesture*>(ptr)->offset()).y());
}
void QPanGesture_SetAcceleration(void* ptr, double value)
{
static_cast<QPanGesture*>(ptr)->setAcceleration(static_cast<double>(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));
}
int QPanGesture_Event(void* ptr, void* e)
{
return static_cast<QPanGesture*>(ptr)->event(static_cast<QEvent*>(e));
}
int QPanGesture_EventDefault(void* ptr, void* e)
{
return static_cast<QPanGesture*>(ptr)->QPanGesture::event(static_cast<QEvent*>(e));
}
int QPanGesture_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QPanGesture*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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 new QPointF(static_cast<QPointF>(static_cast<QPinchGesture*>(ptr)->centerPoint()).x(), static_cast<QPointF>(static_cast<QPinchGesture*>(ptr)->centerPoint()).y());
}
int QPinchGesture_ChangeFlags(void* ptr)
{
return static_cast<QPinchGesture*>(ptr)->changeFlags();
}
void* QPinchGesture_LastCenterPoint(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QPinchGesture*>(ptr)->lastCenterPoint()).x(), static_cast<QPointF>(static_cast<QPinchGesture*>(ptr)->lastCenterPoint()).y());
}
double QPinchGesture_LastRotationAngle(void* ptr)
{
return static_cast<double>(static_cast<QPinchGesture*>(ptr)->lastRotationAngle());
}
double QPinchGesture_LastScaleFactor(void* ptr)
{
return static_cast<double>(static_cast<QPinchGesture*>(ptr)->lastScaleFactor());
}
double QPinchGesture_RotationAngle(void* ptr)
{
return static_cast<double>(static_cast<QPinchGesture*>(ptr)->rotationAngle());
}
double QPinchGesture_ScaleFactor(void* ptr)
{
return static_cast<double>(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, int 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(static_cast<double>(value));
}
void QPinchGesture_SetLastScaleFactor(void* ptr, double value)
{
static_cast<QPinchGesture*>(ptr)->setLastScaleFactor(static_cast<double>(value));
}
void QPinchGesture_SetRotationAngle(void* ptr, double value)
{
static_cast<QPinchGesture*>(ptr)->setRotationAngle(static_cast<double>(value));
}
void QPinchGesture_SetScaleFactor(void* ptr, double value)
{
static_cast<QPinchGesture*>(ptr)->setScaleFactor(static_cast<double>(value));
}
void QPinchGesture_SetStartCenterPoint(void* ptr, void* value)
{
static_cast<QPinchGesture*>(ptr)->setStartCenterPoint(*static_cast<QPointF*>(value));
}
void QPinchGesture_SetTotalChangeFlags(void* ptr, int value)
{
static_cast<QPinchGesture*>(ptr)->setTotalChangeFlags(static_cast<QPinchGesture::ChangeFlag>(value));
}
void QPinchGesture_SetTotalRotationAngle(void* ptr, double value)
{
static_cast<QPinchGesture*>(ptr)->setTotalRotationAngle(static_cast<double>(value));
}
void QPinchGesture_SetTotalScaleFactor(void* ptr, double value)
{
static_cast<QPinchGesture*>(ptr)->setTotalScaleFactor(static_cast<double>(value));
}
void* QPinchGesture_StartCenterPoint(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QPinchGesture*>(ptr)->startCenterPoint()).x(), static_cast<QPointF>(static_cast<QPinchGesture*>(ptr)->startCenterPoint()).y());
}
int QPinchGesture_TotalChangeFlags(void* ptr)
{
return static_cast<QPinchGesture*>(ptr)->totalChangeFlags();
}
double QPinchGesture_TotalRotationAngle(void* ptr)
{
return static_cast<double>(static_cast<QPinchGesture*>(ptr)->totalRotationAngle());
}
double QPinchGesture_TotalScaleFactor(void* ptr)
{
return static_cast<double>(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));
}
int QPinchGesture_Event(void* ptr, void* e)
{
return static_cast<QPinchGesture*>(ptr)->event(static_cast<QEvent*>(e));
}
int QPinchGesture_EventDefault(void* ptr, void* e)
{
return static_cast<QPinchGesture*>(ptr)->QPinchGesture::event(static_cast<QEvent*>(e));
}
int QPinchGesture_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QPinchGesture*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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 new QRectF(static_cast<QRectF>(static_cast<QPlainTextDocumentLayout*>(ptr)->blockBoundingRect(*static_cast<QTextBlock*>(block))).x(), static_cast<QRectF>(static_cast<QPlainTextDocumentLayout*>(ptr)->blockBoundingRect(*static_cast<QTextBlock*>(block))).y(), static_cast<QRectF>(static_cast<QPlainTextDocumentLayout*>(ptr)->blockBoundingRect(*static_cast<QTextBlock*>(block))).width(), static_cast<QRectF>(static_cast<QPlainTextDocumentLayout*>(ptr)->blockBoundingRect(*static_cast<QTextBlock*>(block))).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 new QSizeF(static_cast<QSizeF>(static_cast<QPlainTextDocumentLayout*>(ptr)->documentSize()).width(), static_cast<QSizeF>(static_cast<QPlainTextDocumentLayout*>(ptr)->documentSize()).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 new QRectF(static_cast<QRectF>(static_cast<QPlainTextDocumentLayout*>(ptr)->frameBoundingRect(static_cast<QTextFrame*>(vqt))).x(), static_cast<QRectF>(static_cast<QPlainTextDocumentLayout*>(ptr)->frameBoundingRect(static_cast<QTextFrame*>(vqt))).y(), static_cast<QRectF>(static_cast<QPlainTextDocumentLayout*>(ptr)->frameBoundingRect(static_cast<QTextFrame*>(vqt))).width(), static_cast<QRectF>(static_cast<QPlainTextDocumentLayout*>(ptr)->frameBoundingRect(static_cast<QTextFrame*>(vqt))).height());
}
int QPlainTextDocumentLayout_HitTest(void* ptr, void* vqp, int 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));
}
int QPlainTextDocumentLayout_Event(void* ptr, void* e)
{
return static_cast<QPlainTextDocumentLayout*>(ptr)->event(static_cast<QEvent*>(e));
}
int QPlainTextDocumentLayout_EventDefault(void* ptr, void* e)
{
return static_cast<QPlainTextDocumentLayout*>(ptr)->QPlainTextDocumentLayout::event(static_cast<QEvent*>(e));
}
int QPlainTextDocumentLayout_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QPlainTextDocumentLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), event); };
void redo() { callbackQPlainTextEdit_Redo(this, this->objectName().toUtf8().data()); };
void zoomIn(int ran) { callbackQPlainTextEdit_ZoomIn(this, this->objectName().toUtf8().data(), ran); };
void zoomOut(int ran) { callbackQPlainTextEdit_ZoomOut(this, this->objectName().toUtf8().data(), ran); };
void appendHtml(const QString & html) { callbackQPlainTextEdit_AppendHtml(this, this->objectName().toUtf8().data(), html.toUtf8().data()); };
void appendPlainText(const QString & text) { callbackQPlainTextEdit_AppendPlainText(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void Signal_BlockCountChanged(int newBlockCount) { callbackQPlainTextEdit_BlockCountChanged(this, this->objectName().toUtf8().data(), newBlockCount); };
bool canInsertFromMimeData(const QMimeData * source) const { return callbackQPlainTextEdit_CanInsertFromMimeData(const_cast<MyQPlainTextEdit*>(this), this->objectName().toUtf8().data(), const_cast<QMimeData*>(source)) != 0; };
void centerCursor() { callbackQPlainTextEdit_CenterCursor(this, this->objectName().toUtf8().data()); };
void changeEvent(QEvent * e) { callbackQPlainTextEdit_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void clear() { callbackQPlainTextEdit_Clear(this, this->objectName().toUtf8().data()); };
void copy() { callbackQPlainTextEdit_Copy(this, this->objectName().toUtf8().data()); };
void Signal_CopyAvailable(bool yes) { callbackQPlainTextEdit_CopyAvailable(this, this->objectName().toUtf8().data(), yes); };
QMimeData * createMimeDataFromSelection() const { return static_cast<QMimeData*>(callbackQPlainTextEdit_CreateMimeDataFromSelection(const_cast<MyQPlainTextEdit*>(this), this->objectName().toUtf8().data())); };
void Signal_CursorPositionChanged() { callbackQPlainTextEdit_CursorPositionChanged(this, this->objectName().toUtf8().data()); };
void cut() { callbackQPlainTextEdit_Cut(this, this->objectName().toUtf8().data()); };
void dragEnterEvent(QDragEnterEvent * e) { callbackQPlainTextEdit_DragEnterEvent(this, this->objectName().toUtf8().data(), e); };
void dragLeaveEvent(QDragLeaveEvent * e) { callbackQPlainTextEdit_DragLeaveEvent(this, this->objectName().toUtf8().data(), e); };
void dragMoveEvent(QDragMoveEvent * e) { callbackQPlainTextEdit_DragMoveEvent(this, this->objectName().toUtf8().data(), e); };
void dropEvent(QDropEvent * e) { callbackQPlainTextEdit_DropEvent(this, this->objectName().toUtf8().data(), e); };
void focusInEvent(QFocusEvent * e) { callbackQPlainTextEdit_FocusInEvent(this, this->objectName().toUtf8().data(), e); };
bool focusNextPrevChild(bool next) { return callbackQPlainTextEdit_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * e) { callbackQPlainTextEdit_FocusOutEvent(this, this->objectName().toUtf8().data(), e); };
void inputMethodEvent(QInputMethodEvent * e) { callbackQPlainTextEdit_InputMethodEvent(this, this->objectName().toUtf8().data(), e); };
QVariant inputMethodQuery(Qt::InputMethodQuery property) const { return *static_cast<QVariant*>(callbackQPlainTextEdit_InputMethodQuery(const_cast<MyQPlainTextEdit*>(this), this->objectName().toUtf8().data(), property)); };
void insertFromMimeData(const QMimeData * source) { callbackQPlainTextEdit_InsertFromMimeData(this, this->objectName().toUtf8().data(), const_cast<QMimeData*>(source)); };
void insertPlainText(const QString & text) { callbackQPlainTextEdit_InsertPlainText(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void keyPressEvent(QKeyEvent * e) { callbackQPlainTextEdit_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void keyReleaseEvent(QKeyEvent * e) { callbackQPlainTextEdit_KeyReleaseEvent(this, this->objectName().toUtf8().data(), e); };
QVariant loadResource(int ty, const QUrl & name) { return *static_cast<QVariant*>(callbackQPlainTextEdit_LoadResource(this, this->objectName().toUtf8().data(), ty, new QUrl(name))); };
void Signal_ModificationChanged(bool changed) { callbackQPlainTextEdit_ModificationChanged(this, this->objectName().toUtf8().data(), changed); };
void mouseDoubleClickEvent(QMouseEvent * e) { callbackQPlainTextEdit_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), e); };
void mouseMoveEvent(QMouseEvent * e) { callbackQPlainTextEdit_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQPlainTextEdit_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQPlainTextEdit_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void paintEvent(QPaintEvent * e) { callbackQPlainTextEdit_PaintEvent(this, this->objectName().toUtf8().data(), e); };
void paste() { callbackQPlainTextEdit_Paste(this, this->objectName().toUtf8().data()); };
void Signal_RedoAvailable(bool available) { callbackQPlainTextEdit_RedoAvailable(this, this->objectName().toUtf8().data(), available); };
void resizeEvent(QResizeEvent * e) { callbackQPlainTextEdit_ResizeEvent(this, this->objectName().toUtf8().data(), e); };
void scrollContentsBy(int dx, int dy) { callbackQPlainTextEdit_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void selectAll() { callbackQPlainTextEdit_SelectAll(this, this->objectName().toUtf8().data()); };
void Signal_SelectionChanged() { callbackQPlainTextEdit_SelectionChanged(this, this->objectName().toUtf8().data()); };
void setPlainText(const QString & text) { callbackQPlainTextEdit_SetPlainText(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void showEvent(QShowEvent * vqs) { callbackQPlainTextEdit_ShowEvent(this, this->objectName().toUtf8().data(), vqs); };
void Signal_TextChanged() { callbackQPlainTextEdit_TextChanged(this, this->objectName().toUtf8().data()); };
void undo() { callbackQPlainTextEdit_Undo(this, this->objectName().toUtf8().data()); };
void Signal_UndoAvailable(bool available) { callbackQPlainTextEdit_UndoAvailable(this, this->objectName().toUtf8().data(), available); };
void Signal_UpdateRequest(const QRect & rect, int dy) { callbackQPlainTextEdit_UpdateRequest(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), dy); };
void wheelEvent(QWheelEvent * e) { callbackQPlainTextEdit_WheelEvent(this, this->objectName().toUtf8().data(), e); };
bool viewportEvent(QEvent * event) { return callbackQPlainTextEdit_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQPlainTextEdit_MinimumSizeHint(const_cast<MyQPlainTextEdit*>(this), this->objectName().toUtf8().data())); };
void setupViewport(QWidget * viewport) { callbackQPlainTextEdit_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQPlainTextEdit_SizeHint(const_cast<MyQPlainTextEdit*>(this), this->objectName().toUtf8().data())); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQPlainTextEdit_ViewportSizeHint(const_cast<MyQPlainTextEdit*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQPlainTextEdit_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQPlainTextEdit_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQPlainTextEdit_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQPlainTextEdit_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQPlainTextEdit_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQPlainTextEdit_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQPlainTextEdit_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQPlainTextEdit_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQPlainTextEdit_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQPlainTextEdit_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQPlainTextEdit_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQPlainTextEdit_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQPlainTextEdit_HasHeightForWidth(const_cast<MyQPlainTextEdit*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQPlainTextEdit_HeightForWidth(const_cast<MyQPlainTextEdit*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQPlainTextEdit_Hide(this, this->objectName().toUtf8().data()); };
void lower() { callbackQPlainTextEdit_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQPlainTextEdit_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQPlainTextEdit_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQPlainTextEdit_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQPlainTextEdit_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQPlainTextEdit_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQPlainTextEdit_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQPlainTextEdit_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQPlainTextEdit_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQPlainTextEdit_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQPlainTextEdit_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQPlainTextEdit_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQPlainTextEdit_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQPlainTextEdit_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQPlainTextEdit_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQPlainTextEdit_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQPlainTextEdit_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQPlainTextEdit_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQPlainTextEdit_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQPlainTextEdit_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQPlainTextEdit_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQPlainTextEdit_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQPlainTextEdit_MetaObject(const_cast<MyQPlainTextEdit*>(this), this->objectName().toUtf8().data())); };
};
int QPlainTextEdit_BackgroundVisible(void* ptr)
{
return static_cast<QPlainTextEdit*>(ptr)->backgroundVisible();
}
int QPlainTextEdit_BlockCount(void* ptr)
{
return static_cast<QPlainTextEdit*>(ptr)->blockCount();
}
int 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();
}
int QPlainTextEdit_Find2(void* ptr, void* exp, int options)
{
return static_cast<QPlainTextEdit*>(ptr)->find(*static_cast<QRegExp*>(exp), static_cast<QTextDocument::FindFlag>(options));
}
int QPlainTextEdit_IsReadOnly(void* ptr)
{
return static_cast<QPlainTextEdit*>(ptr)->isReadOnly();
}
int QPlainTextEdit_LineWrapMode(void* ptr)
{
return static_cast<QPlainTextEdit*>(ptr)->lineWrapMode();
}
int QPlainTextEdit_OverwriteMode(void* ptr)
{
return static_cast<QPlainTextEdit*>(ptr)->overwriteMode();
}
char* QPlainTextEdit_PlaceholderText(void* ptr)
{
return static_cast<QPlainTextEdit*>(ptr)->placeholderText().toUtf8().data();
}
void QPlainTextEdit_Redo(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "redo");
}
void QPlainTextEdit_SetBackgroundVisible(void* ptr, int visible)
{
static_cast<QPlainTextEdit*>(ptr)->setBackgroundVisible(visible != 0);
}
void QPlainTextEdit_SetCenterOnScroll(void* ptr, int 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, int mode)
{
static_cast<QPlainTextEdit*>(ptr)->setLineWrapMode(static_cast<QPlainTextEdit::LineWrapMode>(mode));
}
void QPlainTextEdit_SetOverwriteMode(void* ptr, int 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, int ro)
{
static_cast<QPlainTextEdit*>(ptr)->setReadOnly(ro != 0);
}
void QPlainTextEdit_SetTabChangesFocus(void* ptr, int 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, int flags)
{
static_cast<QPlainTextEdit*>(ptr)->setTextInteractionFlags(static_cast<Qt::TextInteractionFlag>(flags));
}
void QPlainTextEdit_SetWordWrapMode(void* ptr, int policy)
{
static_cast<QPlainTextEdit*>(ptr)->setWordWrapMode(static_cast<QTextOption::WrapMode>(policy));
}
int QPlainTextEdit_TabChangesFocus(void* ptr)
{
return static_cast<QPlainTextEdit*>(ptr)->tabChangesFocus();
}
int QPlainTextEdit_TabStopWidth(void* ptr)
{
return static_cast<QPlainTextEdit*>(ptr)->tabStopWidth();
}
int QPlainTextEdit_TextInteractionFlags(void* ptr)
{
return static_cast<QPlainTextEdit*>(ptr)->textInteractionFlags();
}
int 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 static_cast<QPlainTextEdit*>(ptr)->anchorAt(*static_cast<QPoint*>(pos)).toUtf8().data();
}
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 new QRectF(static_cast<QRectF>(static_cast<QPlainTextEdit*>(ptr)->blockBoundingGeometry(*static_cast<QTextBlock*>(block))).x(), static_cast<QRectF>(static_cast<QPlainTextEdit*>(ptr)->blockBoundingGeometry(*static_cast<QTextBlock*>(block))).y(), static_cast<QRectF>(static_cast<QPlainTextEdit*>(ptr)->blockBoundingGeometry(*static_cast<QTextBlock*>(block))).width(), static_cast<QRectF>(static_cast<QPlainTextEdit*>(ptr)->blockBoundingGeometry(*static_cast<QTextBlock*>(block))).height());
}
void* QPlainTextEdit_BlockBoundingRect(void* ptr, void* block)
{
return new QRectF(static_cast<QRectF>(static_cast<QPlainTextEdit*>(ptr)->blockBoundingRect(*static_cast<QTextBlock*>(block))).x(), static_cast<QRectF>(static_cast<QPlainTextEdit*>(ptr)->blockBoundingRect(*static_cast<QTextBlock*>(block))).y(), static_cast<QRectF>(static_cast<QPlainTextEdit*>(ptr)->blockBoundingRect(*static_cast<QTextBlock*>(block))).width(), static_cast<QRectF>(static_cast<QPlainTextEdit*>(ptr)->blockBoundingRect(*static_cast<QTextBlock*>(block))).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);
}
int QPlainTextEdit_CanInsertFromMimeData(void* ptr, void* source)
{
return static_cast<QPlainTextEdit*>(ptr)->canInsertFromMimeData(static_cast<QMimeData*>(source));
}
int QPlainTextEdit_CanInsertFromMimeDataDefault(void* ptr, void* source)
{
return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::canInsertFromMimeData(static_cast<QMimeData*>(source));
}
int 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 new QPointF(static_cast<QPointF>(static_cast<QPlainTextEdit*>(ptr)->contentOffset()).x(), static_cast<QPointF>(static_cast<QPlainTextEdit*>(ptr)->contentOffset()).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, int 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 new QRect(static_cast<QRect>(static_cast<QPlainTextEdit*>(ptr)->cursorRect()).x(), static_cast<QRect>(static_cast<QPlainTextEdit*>(ptr)->cursorRect()).y(), static_cast<QRect>(static_cast<QPlainTextEdit*>(ptr)->cursorRect()).width(), static_cast<QRect>(static_cast<QPlainTextEdit*>(ptr)->cursorRect()).height());
}
void* QPlainTextEdit_CursorRect(void* ptr, void* cursor)
{
return new QRect(static_cast<QRect>(static_cast<QPlainTextEdit*>(ptr)->cursorRect(*static_cast<QTextCursor*>(cursor))).x(), static_cast<QRect>(static_cast<QPlainTextEdit*>(ptr)->cursorRect(*static_cast<QTextCursor*>(cursor))).y(), static_cast<QRect>(static_cast<QPlainTextEdit*>(ptr)->cursorRect(*static_cast<QTextCursor*>(cursor))).width(), static_cast<QRect>(static_cast<QPlainTextEdit*>(ptr)->cursorRect(*static_cast<QTextCursor*>(cursor))).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 static_cast<QPlainTextEdit*>(ptr)->documentTitle().toUtf8().data();
}
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();
}
int QPlainTextEdit_Find(void* ptr, char* exp, int 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));
}
int QPlainTextEdit_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QPlainTextEdit*>(ptr)->focusNextPrevChild(next != 0);
}
int QPlainTextEdit_FocusNextPrevChildDefault(void* ptr, int 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, int property)
{
return new QVariant(static_cast<QPlainTextEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(property)));
}
void* QPlainTextEdit_InputMethodQueryDefault(void* ptr, int 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)));
}
int 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, int 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, int operation, int 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, int 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, int 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 static_cast<QPlainTextEdit*>(ptr)->toPlainText().toUtf8().data();
}
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, int 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();
}
int QPlainTextEdit_ViewportEvent(void* ptr, void* event)
{
return static_cast<QPlainTextEdit*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int QPlainTextEdit_ViewportEventDefault(void* ptr, void* event)
{
return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::viewportEvent(static_cast<QEvent*>(event));
}
void* QPlainTextEdit_MinimumSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QPlainTextEdit*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QPlainTextEdit*>(ptr)->minimumSizeHint()).height());
}
void* QPlainTextEdit_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QPlainTextEdit*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QPlainTextEdit*>(ptr)->sizeHint()).height());
}
void* QPlainTextEdit_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::sizeHint()).width(), static_cast<QSize>(static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::sizeHint()).height());
}
void* QPlainTextEdit_ViewportSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QPlainTextEdit*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QPlainTextEdit*>(ptr)->viewportSizeHint()).height());
}
void* QPlainTextEdit_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::viewportSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QPlainTextEdit_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QPlainTextEdit_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::setVisible(visible != 0);
}
void QPlainTextEdit_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QPlainTextEdit_SetWindowModifiedDefault(void* ptr, int 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));
}
int QPlainTextEdit_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QPlainTextEdit_HasHeightForWidth(void* ptr)
{
return static_cast<QPlainTextEdit*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QPlainTextEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QPlainTextEdit*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QPlainTextEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QPlainTextEdit*>(ptr)->QPlainTextEdit::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QPlainTextEdit_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QPlainTextEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QPlainTextEdit_SetHiddenDefault(void* ptr, int 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));
}
int QPlainTextEdit_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QPlainTextEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), maximum); };
void setMinimum(int minimum) { callbackQProgressBar_SetMinimum(this, this->objectName().toUtf8().data(), minimum); };
void setOrientation(Qt::Orientation vqt) { callbackQProgressBar_SetOrientation(this, this->objectName().toUtf8().data(), vqt); };
void setValue(int value) { callbackQProgressBar_SetValue(this, this->objectName().toUtf8().data(), value); };
QString text() const { return QString(callbackQProgressBar_Text(const_cast<MyQProgressBar*>(this), this->objectName().toUtf8().data())); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQProgressBar_MinimumSizeHint(const_cast<MyQProgressBar*>(this), this->objectName().toUtf8().data())); };
void paintEvent(QPaintEvent * vqp) { callbackQProgressBar_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
void reset() { callbackQProgressBar_Reset(this, this->objectName().toUtf8().data()); };
void setRange(int minimum, int maximum) { callbackQProgressBar_SetRange(this, this->objectName().toUtf8().data(), minimum, maximum); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQProgressBar_SizeHint(const_cast<MyQProgressBar*>(this), this->objectName().toUtf8().data())); };
void Signal_ValueChanged(int value) { callbackQProgressBar_ValueChanged(this, this->objectName().toUtf8().data(), value); };
void actionEvent(QActionEvent * event) { callbackQProgressBar_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQProgressBar_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQProgressBar_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQProgressBar_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQProgressBar_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQProgressBar_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQProgressBar_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQProgressBar_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQProgressBar_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQProgressBar_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQProgressBar_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQProgressBar_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQProgressBar_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQProgressBar_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQProgressBar_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQProgressBar_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQProgressBar_ShowEvent(this, this->objectName().toUtf8().data(), event); };
void changeEvent(QEvent * event) { callbackQProgressBar_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQProgressBar_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQProgressBar_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQProgressBar_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQProgressBar_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQProgressBar_HasHeightForWidth(const_cast<MyQProgressBar*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQProgressBar_HeightForWidth(const_cast<MyQProgressBar*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQProgressBar_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQProgressBar_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQProgressBar_InputMethodQuery(const_cast<MyQProgressBar*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQProgressBar_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQProgressBar_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQProgressBar_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQProgressBar_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQProgressBar_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQProgressBar_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQProgressBar_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQProgressBar_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQProgressBar_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQProgressBar_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQProgressBar_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQProgressBar_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQProgressBar_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQProgressBar_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQProgressBar_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQProgressBar_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQProgressBar_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQProgressBar_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQProgressBar_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQProgressBar_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQProgressBar_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQProgressBar_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQProgressBar_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQProgressBar_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQProgressBar_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQProgressBar_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQProgressBar_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQProgressBar_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQProgressBar_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQProgressBar_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQProgressBar_MetaObject(const_cast<MyQProgressBar*>(this), this->objectName().toUtf8().data())); };
};
int QProgressBar_Alignment(void* ptr)
{
return static_cast<QProgressBar*>(ptr)->alignment();
}
char* QProgressBar_Format(void* ptr)
{
return static_cast<QProgressBar*>(ptr)->format().toUtf8().data();
}
int QProgressBar_InvertedAppearance(void* ptr)
{
return static_cast<QProgressBar*>(ptr)->invertedAppearance();
}
int 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();
}
int 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, int 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, int 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, int vqt)
{
QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setOrientation", Q_ARG(Qt::Orientation, static_cast<Qt::Orientation>(vqt)));
}
void QProgressBar_SetTextDirection(void* ptr, int textDirection)
{
static_cast<QProgressBar*>(ptr)->setTextDirection(static_cast<QProgressBar::Direction>(textDirection));
}
void QProgressBar_SetTextVisible(void* ptr, int 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 static_cast<QProgressBar*>(ptr)->text().toUtf8().data();
}
char* QProgressBar_TextDefault(void* ptr)
{
return static_cast<QProgressBar*>(ptr)->QProgressBar::text().toUtf8().data();
}
int 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));
}
int 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 new QSize(static_cast<QSize>(static_cast<QProgressBar*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QProgressBar*>(ptr)->minimumSizeHint()).height());
}
void* QProgressBar_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QProgressBar*>(ptr)->QProgressBar::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QProgressBar*>(ptr)->QProgressBar::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QProgressBar*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QProgressBar*>(ptr)->sizeHint()).height());
}
void* QProgressBar_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QProgressBar*>(ptr)->QProgressBar::sizeHint()).width(), static_cast<QSize>(static_cast<QProgressBar*>(ptr)->QProgressBar::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QProgressBar_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QProgressBar_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QProgressBar*>(ptr)->QProgressBar::setVisible(visible != 0);
}
void QProgressBar_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QProgressBar_SetWindowModifiedDefault(void* ptr, int 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));
}
int QProgressBar_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QProgressBar_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QProgressBar*>(ptr)->focusNextPrevChild(next != 0);
}
int QProgressBar_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QProgressBar*>(ptr)->QProgressBar::focusNextPrevChild(next != 0);
}
int QProgressBar_HasHeightForWidth(void* ptr)
{
return static_cast<QProgressBar*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QProgressBar*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QProgressBar_InputMethodQueryDefault(void* ptr, int 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));
}
int QProgressBar_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QProgressBar*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QProgressBar_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QProgressBar*>(ptr)->QProgressBar::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QProgressBar_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QProgressBar*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QProgressBar_SetHiddenDefault(void* ptr, int 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));
}
int QProgressBar_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QProgressBar*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void setMaximum(int maximum) { callbackQProgressDialog_SetMaximum(this, this->objectName().toUtf8().data(), maximum); };
void setMinimum(int minimum) { callbackQProgressDialog_SetMinimum(this, this->objectName().toUtf8().data(), minimum); };
void setMinimumDuration(int ms) { callbackQProgressDialog_SetMinimumDuration(this, this->objectName().toUtf8().data(), ms); };
void setValue(int progress) { callbackQProgressDialog_SetValue(this, this->objectName().toUtf8().data(), progress); };
void cancel() { callbackQProgressDialog_Cancel(this, this->objectName().toUtf8().data()); };
void Signal_Canceled() { callbackQProgressDialog_Canceled(this, this->objectName().toUtf8().data()); };
void changeEvent(QEvent * ev) { callbackQProgressDialog_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void closeEvent(QCloseEvent * e) { callbackQProgressDialog_CloseEvent(this, this->objectName().toUtf8().data(), e); };
void forceShow() { callbackQProgressDialog_ForceShow(this, this->objectName().toUtf8().data()); };
void reset() { callbackQProgressDialog_Reset(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQProgressDialog_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setCancelButtonText(const QString & cancelButtonText) { callbackQProgressDialog_SetCancelButtonText(this, this->objectName().toUtf8().data(), cancelButtonText.toUtf8().data()); };
void setRange(int minimum, int maximum) { callbackQProgressDialog_SetRange(this, this->objectName().toUtf8().data(), minimum, maximum); };
void showEvent(QShowEvent * e) { callbackQProgressDialog_ShowEvent(this, this->objectName().toUtf8().data(), e); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQProgressDialog_SizeHint(const_cast<MyQProgressDialog*>(this), this->objectName().toUtf8().data())); };
void accept() { callbackQProgressDialog_Accept(this, this->objectName().toUtf8().data()); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQProgressDialog_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
void done(int r) { callbackQProgressDialog_Done(this, this->objectName().toUtf8().data(), r); };
int exec() { return callbackQProgressDialog_Exec(this, this->objectName().toUtf8().data()); };
void keyPressEvent(QKeyEvent * e) { callbackQProgressDialog_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQProgressDialog_MinimumSizeHint(const_cast<MyQProgressDialog*>(this), this->objectName().toUtf8().data())); };
void reject() { callbackQProgressDialog_Reject(this, this->objectName().toUtf8().data()); };
void setVisible(bool visible) { callbackQProgressDialog_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void actionEvent(QActionEvent * event) { callbackQProgressDialog_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQProgressDialog_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQProgressDialog_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQProgressDialog_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQProgressDialog_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQProgressDialog_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQProgressDialog_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQProgressDialog_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQProgressDialog_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQProgressDialog_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQProgressDialog_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQProgressDialog_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQProgressDialog_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQProgressDialog_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setWindowModified(bool vbo) { callbackQProgressDialog_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQProgressDialog_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQProgressDialog_Close(this, this->objectName().toUtf8().data()) != 0; };
bool focusNextPrevChild(bool next) { return callbackQProgressDialog_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQProgressDialog_HasHeightForWidth(const_cast<MyQProgressDialog*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQProgressDialog_HeightForWidth(const_cast<MyQProgressDialog*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQProgressDialog_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQProgressDialog_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQProgressDialog_InputMethodQuery(const_cast<MyQProgressDialog*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQProgressDialog_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQProgressDialog_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQProgressDialog_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQProgressDialog_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQProgressDialog_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQProgressDialog_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQProgressDialog_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQProgressDialog_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQProgressDialog_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQProgressDialog_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQProgressDialog_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQProgressDialog_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQProgressDialog_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQProgressDialog_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQProgressDialog_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQProgressDialog_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQProgressDialog_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQProgressDialog_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQProgressDialog_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQProgressDialog_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQProgressDialog_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQProgressDialog_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQProgressDialog_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQProgressDialog_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQProgressDialog_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQProgressDialog_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQProgressDialog_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQProgressDialog_MetaObject(const_cast<MyQProgressDialog*>(this), this->objectName().toUtf8().data())); };
};
int QProgressDialog_AutoClose(void* ptr)
{
return static_cast<QProgressDialog*>(ptr)->autoClose();
}
int QProgressDialog_AutoReset(void* ptr)
{
return static_cast<QProgressDialog*>(ptr)->autoReset();
}
char* QProgressDialog_LabelText(void* ptr)
{
return static_cast<QProgressDialog*>(ptr)->labelText().toUtf8().data();
}
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, int close)
{
static_cast<QProgressDialog*>(ptr)->setAutoClose(close != 0);
}
void QProgressDialog_SetAutoReset(void* ptr, int 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();
}
int QProgressDialog_WasCanceled(void* ptr)
{
return static_cast<QProgressDialog*>(ptr)->wasCanceled();
}
void* QProgressDialog_NewQProgressDialog(void* parent, int 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, int 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 new QSize(static_cast<QSize>(static_cast<QProgressDialog*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QProgressDialog*>(ptr)->sizeHint()).height());
}
void* QProgressDialog_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QProgressDialog*>(ptr)->QProgressDialog::sizeHint()).width(), static_cast<QSize>(static_cast<QProgressDialog*>(ptr)->QProgressDialog::sizeHint()).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 new QSize(static_cast<QSize>(static_cast<QProgressDialog*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QProgressDialog*>(ptr)->minimumSizeHint()).height());
}
void* QProgressDialog_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QProgressDialog*>(ptr)->QProgressDialog::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QProgressDialog*>(ptr)->QProgressDialog::minimumSizeHint()).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, int visible)
{
static_cast<QProgressDialog*>(ptr)->setVisible(visible != 0);
}
void QProgressDialog_SetVisibleDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QProgressDialog_SetEnabledDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QProgressDialog_SetWindowModifiedDefault(void* ptr, int 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));
}
int QProgressDialog_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QProgressDialog_CloseDefault(void* ptr)
{
return static_cast<QProgressDialog*>(ptr)->QProgressDialog::close();
}
int QProgressDialog_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QProgressDialog*>(ptr)->focusNextPrevChild(next != 0);
}
int QProgressDialog_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QProgressDialog*>(ptr)->QProgressDialog::focusNextPrevChild(next != 0);
}
int QProgressDialog_HasHeightForWidth(void* ptr)
{
return static_cast<QProgressDialog*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QProgressDialog*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QProgressDialog_InputMethodQueryDefault(void* ptr, int 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));
}
int QProgressDialog_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QProgressDialog*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QProgressDialog_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QProgressDialog*>(ptr)->QProgressDialog::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QProgressDialog_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QProgressDialog*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QProgressDialog_SetHiddenDefault(void* ptr, int 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), painter, new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), alignment, new 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), this->objectName().toUtf8().data(), painter, new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), flags, new QPalette(pal), enabled, text.toUtf8().data(), textRole); };
void drawPrimitive(QStyle::PrimitiveElement element, const QStyleOption * option, QPainter * painter, const QWidget * widget) const { callbackQProxyStyle_DrawPrimitive(const_cast<MyQProxyStyle*>(this), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), iconMode, new 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), this->objectName().toUtf8().data(), control, const_cast<QStyleOptionComplex*>(option), new QPoint(static_cast<QPoint>(pos).x(), static_cast<QPoint>(pos).y()), 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), this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(r).x(), static_cast<QRect>(r).y(), static_cast<QRect>(r).width(), static_cast<QRect>(r).height()), flags, new 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), this->objectName().toUtf8().data(), new QFontMetrics(fm), new QRect(static_cast<QRect>(r).x(), static_cast<QRect>(r).y(), static_cast<QRect>(r).width(), static_cast<QRect>(r).height()), flags, enabled, text.toUtf8().data())); };
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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), metric, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget)); };
void polish(QApplication * app) { callbackQProxyStyle_Polish3(this, this->objectName().toUtf8().data(), app); };
void polish(QPalette & pal) { callbackQProxyStyle_Polish2(this, this->objectName().toUtf8().data(), new QPalette(pal)); };
void polish(QWidget * widget) { callbackQProxyStyle_Polish(this, this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), ty, const_cast<QStyleOption*>(option), new QSize(static_cast<QSize>(size).width(), static_cast<QSize>(size).height()), 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), this->objectName().toUtf8().data(), standardIcon, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
QPalette standardPalette() const { return *static_cast<QPalette*>(callbackQProxyStyle_StandardPalette(const_cast<MyQProxyStyle*>(this), this->objectName().toUtf8().data())); };
QPixmap standardPixmap(QStyle::StandardPixmap standardPixmap, const QStyleOption * opt, const QWidget * widget) const { return *static_cast<QPixmap*>(callbackQProxyStyle_StandardPixmap(const_cast<MyQProxyStyle*>(this), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), element, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
void unpolish(QApplication * app) { callbackQProxyStyle_Unpolish2(this, this->objectName().toUtf8().data(), app); };
void unpolish(QWidget * widget) { callbackQProxyStyle_Unpolish(this, this->objectName().toUtf8().data(), widget); };
void timerEvent(QTimerEvent * event) { callbackQProxyStyle_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQProxyStyle_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQProxyStyle_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQProxyStyle_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQProxyStyle_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQProxyStyle_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQProxyStyle_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQProxyStyle_MetaObject(const_cast<MyQProxyStyle*>(this), this->objectName().toUtf8().data())); };
};
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, int 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, int 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, int 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, int 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, int enabled, char* text, int 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, int enabled, char* text, int 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, int 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, int 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));
}
int QProxyStyle_Event(void* ptr, void* e)
{
return static_cast<QProxyStyle*>(ptr)->event(static_cast<QEvent*>(e));
}
void* QProxyStyle_GeneratedIconPixmap(void* ptr, int 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, int 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)));
}
int QProxyStyle_HitTestComplexControl(void* ptr, int 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));
}
int QProxyStyle_HitTestComplexControlDefault(void* ptr, int 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 new QRect(static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(r), flags, *static_cast<QPixmap*>(pixmap))).x(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(r), flags, *static_cast<QPixmap*>(pixmap))).y(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(r), flags, *static_cast<QPixmap*>(pixmap))).width(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(r), flags, *static_cast<QPixmap*>(pixmap))).height());
}
void* QProxyStyle_ItemPixmapRectDefault(void* ptr, void* r, int flags, void* pixmap)
{
return new QRect(static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::itemPixmapRect(*static_cast<QRect*>(r), flags, *static_cast<QPixmap*>(pixmap))).x(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::itemPixmapRect(*static_cast<QRect*>(r), flags, *static_cast<QPixmap*>(pixmap))).y(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::itemPixmapRect(*static_cast<QRect*>(r), flags, *static_cast<QPixmap*>(pixmap))).width(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::itemPixmapRect(*static_cast<QRect*>(r), flags, *static_cast<QPixmap*>(pixmap))).height());
}
void* QProxyStyle_ItemTextRect(void* ptr, void* fm, void* r, int flags, int enabled, char* text)
{
return new QRect(static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(fm), *static_cast<QRect*>(r), flags, enabled != 0, QString(text))).x(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(fm), *static_cast<QRect*>(r), flags, enabled != 0, QString(text))).y(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(fm), *static_cast<QRect*>(r), flags, enabled != 0, QString(text))).width(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(fm), *static_cast<QRect*>(r), flags, enabled != 0, QString(text))).height());
}
void* QProxyStyle_ItemTextRectDefault(void* ptr, void* fm, void* r, int flags, int enabled, char* text)
{
return new QRect(static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::itemTextRect(*static_cast<QFontMetrics*>(fm), *static_cast<QRect*>(r), flags, enabled != 0, QString(text))).x(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::itemTextRect(*static_cast<QFontMetrics*>(fm), *static_cast<QRect*>(r), flags, enabled != 0, QString(text))).y(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::itemTextRect(*static_cast<QFontMetrics*>(fm), *static_cast<QRect*>(r), flags, enabled != 0, QString(text))).width(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::itemTextRect(*static_cast<QFontMetrics*>(fm), *static_cast<QRect*>(r), flags, enabled != 0, QString(text))).height());
}
int QProxyStyle_LayoutSpacing(void* ptr, int control1, int control2, int 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, int control1, int control2, int 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, int 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, int 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, int ty, void* option, void* size, void* widget)
{
return new QSize(static_cast<QSize>(static_cast<QProxyStyle*>(ptr)->sizeFromContents(static_cast<QStyle::ContentsType>(ty), static_cast<QStyleOption*>(option), *static_cast<QSize*>(size), static_cast<QWidget*>(widget))).width(), static_cast<QSize>(static_cast<QProxyStyle*>(ptr)->sizeFromContents(static_cast<QStyle::ContentsType>(ty), static_cast<QStyleOption*>(option), *static_cast<QSize*>(size), static_cast<QWidget*>(widget))).height());
}
void* QProxyStyle_SizeFromContentsDefault(void* ptr, int ty, void* option, void* size, void* widget)
{
return new QSize(static_cast<QSize>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::sizeFromContents(static_cast<QStyle::ContentsType>(ty), static_cast<QStyleOption*>(option), *static_cast<QSize*>(size), static_cast<QWidget*>(widget))).width(), static_cast<QSize>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::sizeFromContents(static_cast<QStyle::ContentsType>(ty), static_cast<QStyleOption*>(option), *static_cast<QSize*>(size), static_cast<QWidget*>(widget))).height());
}
void* QProxyStyle_StandardIcon(void* ptr, int 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, int 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, int 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, int 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, int 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, int 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, int cc, void* option, int sc, void* widget)
{
return new QRect(static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).x(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).y(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).width(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).height());
}
void* QProxyStyle_SubControlRectDefault(void* ptr, int cc, void* option, int sc, void* widget)
{
return new QRect(static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).x(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).y(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).width(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::subControlRect(static_cast<QStyle::ComplexControl>(cc), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(sc), static_cast<QWidget*>(widget))).height());
}
void* QProxyStyle_SubElementRect(void* ptr, int element, void* option, void* widget)
{
return new QRect(static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(element), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget))).x(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(element), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget))).y(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(element), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget))).width(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(element), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget))).height());
}
void* QProxyStyle_SubElementRectDefault(void* ptr, int element, void* option, void* widget)
{
return new QRect(static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::subElementRect(static_cast<QStyle::SubElement>(element), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget))).x(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::subElementRect(static_cast<QStyle::SubElement>(element), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget))).y(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::subElementRect(static_cast<QStyle::SubElement>(element), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget))).width(), static_cast<QRect>(static_cast<QProxyStyle*>(ptr)->QProxyStyle::subElementRect(static_cast<QStyle::SubElement>(element), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget))).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));
}
int QProxyStyle_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QProxyStyle*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), e); };
void focusOutEvent(QFocusEvent * e) { callbackQPushButton_FocusOutEvent(this, this->objectName().toUtf8().data(), e); };
bool hitButton(const QPoint & pos) const { return callbackQPushButton_HitButton(const_cast<MyQPushButton*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(pos).x(), static_cast<QPoint>(pos).y())) != 0; };
void keyPressEvent(QKeyEvent * e) { callbackQPushButton_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQPushButton_MinimumSizeHint(const_cast<MyQPushButton*>(this), this->objectName().toUtf8().data())); };
void paintEvent(QPaintEvent * vqp) { callbackQPushButton_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
void showMenu() { callbackQPushButton_ShowMenu(this, this->objectName().toUtf8().data()); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQPushButton_SizeHint(const_cast<MyQPushButton*>(this), this->objectName().toUtf8().data())); };
void setChecked(bool vbo) { callbackQPushButton_SetChecked(this, this->objectName().toUtf8().data(), vbo); };
void setIconSize(const QSize & size) { callbackQPushButton_SetIconSize(this, this->objectName().toUtf8().data(), new QSize(static_cast<QSize>(size).width(), static_cast<QSize>(size).height())); };
void toggle() { callbackQPushButton_Toggle(this, this->objectName().toUtf8().data()); };
void animateClick(int msec) { callbackQPushButton_AnimateClick(this, this->objectName().toUtf8().data(), msec); };
void changeEvent(QEvent * e) { callbackQPushButton_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void checkStateSet() { callbackQPushButton_CheckStateSet(this, this->objectName().toUtf8().data()); };
void click() { callbackQPushButton_Click(this, this->objectName().toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * e) { callbackQPushButton_KeyReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void mouseMoveEvent(QMouseEvent * e) { callbackQPushButton_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQPushButton_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQPushButton_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void nextCheckState() { callbackQPushButton_NextCheckState(this, this->objectName().toUtf8().data()); };
void actionEvent(QActionEvent * event) { callbackQPushButton_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQPushButton_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQPushButton_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQPushButton_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQPushButton_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQPushButton_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQPushButton_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQPushButton_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQPushButton_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQPushButton_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQPushButton_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQPushButton_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQPushButton_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQPushButton_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQPushButton_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQPushButton_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQPushButton_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQPushButton_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQPushButton_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQPushButton_HasHeightForWidth(const_cast<MyQPushButton*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQPushButton_HeightForWidth(const_cast<MyQPushButton*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQPushButton_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQPushButton_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQPushButton_InputMethodQuery(const_cast<MyQPushButton*>(this), this->objectName().toUtf8().data(), query)); };
void lower() { callbackQPushButton_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQPushButton_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQPushButton_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQPushButton_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQPushButton_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQPushButton_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQPushButton_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQPushButton_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQPushButton_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQPushButton_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQPushButton_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQPushButton_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQPushButton_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQPushButton_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQPushButton_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQPushButton_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQPushButton_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQPushButton_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQPushButton_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQPushButton_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQPushButton_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQPushButton_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQPushButton_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQPushButton_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQPushButton_MetaObject(const_cast<MyQPushButton*>(this), this->objectName().toUtf8().data())); };
};
int QPushButton_AutoDefault(void* ptr)
{
return static_cast<QPushButton*>(ptr)->autoDefault();
}
int QPushButton_IsDefault(void* ptr)
{
return static_cast<QPushButton*>(ptr)->isDefault();
}
int QPushButton_IsFlat(void* ptr)
{
return static_cast<QPushButton*>(ptr)->isFlat();
}
void QPushButton_SetAutoDefault(void* ptr, int vbo)
{
static_cast<QPushButton*>(ptr)->setAutoDefault(vbo != 0);
}
void QPushButton_SetDefault(void* ptr, int vbo)
{
static_cast<QPushButton*>(ptr)->setDefault(vbo != 0);
}
void QPushButton_SetFlat(void* ptr, int 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));
}
int 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));
}
int QPushButton_HitButton(void* ptr, void* pos)
{
return static_cast<QPushButton*>(ptr)->hitButton(*static_cast<QPoint*>(pos));
}
int 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 new QSize(static_cast<QSize>(static_cast<QPushButton*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QPushButton*>(ptr)->minimumSizeHint()).height());
}
void* QPushButton_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QPushButton*>(ptr)->QPushButton::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QPushButton*>(ptr)->QPushButton::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QPushButton*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QPushButton*>(ptr)->sizeHint()).height());
}
void* QPushButton_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QPushButton*>(ptr)->QPushButton::sizeHint()).width(), static_cast<QSize>(static_cast<QPushButton*>(ptr)->QPushButton::sizeHint()).height());
}
void QPushButton_DestroyQPushButton(void* ptr)
{
static_cast<QPushButton*>(ptr)->~QPushButton();
}
void QPushButton_SetChecked(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}
void QPushButton_SetCheckedDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QPushButton_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QPushButton_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QPushButton*>(ptr)->QPushButton::setVisible(visible != 0);
}
void QPushButton_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QPushButton_SetWindowModifiedDefault(void* ptr, int 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));
}
int QPushButton_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QPushButton_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QPushButton*>(ptr)->focusNextPrevChild(next != 0);
}
int QPushButton_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QPushButton*>(ptr)->QPushButton::focusNextPrevChild(next != 0);
}
int QPushButton_HasHeightForWidth(void* ptr)
{
return static_cast<QPushButton*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QPushButton*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QPushButton_InputMethodQueryDefault(void* ptr, int 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));
}
int QPushButton_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QPushButton*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QPushButton_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QPushButton*>(ptr)->QPushButton::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QPushButton_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QPushButton*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QPushButton_SetHiddenDefault(void* ptr, int 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));
}
int QPushButton_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QPushButton*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(pos).x(), static_cast<QPoint>(pos).y())) != 0; };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQRadioButton_MinimumSizeHint(const_cast<MyQRadioButton*>(this), this->objectName().toUtf8().data())); };
void mouseMoveEvent(QMouseEvent * e) { callbackQRadioButton_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void paintEvent(QPaintEvent * vqp) { callbackQRadioButton_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQRadioButton_SizeHint(const_cast<MyQRadioButton*>(this), this->objectName().toUtf8().data())); };
void setChecked(bool vbo) { callbackQRadioButton_SetChecked(this, this->objectName().toUtf8().data(), vbo); };
void setIconSize(const QSize & size) { callbackQRadioButton_SetIconSize(this, this->objectName().toUtf8().data(), new QSize(static_cast<QSize>(size).width(), static_cast<QSize>(size).height())); };
void toggle() { callbackQRadioButton_Toggle(this, this->objectName().toUtf8().data()); };
void animateClick(int msec) { callbackQRadioButton_AnimateClick(this, this->objectName().toUtf8().data(), msec); };
void changeEvent(QEvent * e) { callbackQRadioButton_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void checkStateSet() { callbackQRadioButton_CheckStateSet(this, this->objectName().toUtf8().data()); };
void click() { callbackQRadioButton_Click(this, this->objectName().toUtf8().data()); };
void focusInEvent(QFocusEvent * e) { callbackQRadioButton_FocusInEvent(this, this->objectName().toUtf8().data(), e); };
void focusOutEvent(QFocusEvent * e) { callbackQRadioButton_FocusOutEvent(this, this->objectName().toUtf8().data(), e); };
void keyPressEvent(QKeyEvent * e) { callbackQRadioButton_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void keyReleaseEvent(QKeyEvent * e) { callbackQRadioButton_KeyReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQRadioButton_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQRadioButton_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void nextCheckState() { callbackQRadioButton_NextCheckState(this, this->objectName().toUtf8().data()); };
void actionEvent(QActionEvent * event) { callbackQRadioButton_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQRadioButton_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQRadioButton_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQRadioButton_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQRadioButton_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQRadioButton_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQRadioButton_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQRadioButton_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQRadioButton_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQRadioButton_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQRadioButton_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQRadioButton_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQRadioButton_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQRadioButton_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQRadioButton_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQRadioButton_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQRadioButton_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQRadioButton_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQRadioButton_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQRadioButton_HasHeightForWidth(const_cast<MyQRadioButton*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQRadioButton_HeightForWidth(const_cast<MyQRadioButton*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQRadioButton_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQRadioButton_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQRadioButton_InputMethodQuery(const_cast<MyQRadioButton*>(this), this->objectName().toUtf8().data(), query)); };
void lower() { callbackQRadioButton_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQRadioButton_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQRadioButton_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQRadioButton_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQRadioButton_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQRadioButton_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQRadioButton_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQRadioButton_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQRadioButton_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQRadioButton_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQRadioButton_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQRadioButton_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQRadioButton_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQRadioButton_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQRadioButton_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQRadioButton_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQRadioButton_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQRadioButton_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQRadioButton_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQRadioButton_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQRadioButton_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQRadioButton_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQRadioButton_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQRadioButton_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQRadioButton_MetaObject(const_cast<MyQRadioButton*>(this), this->objectName().toUtf8().data())); };
};
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));
}
int QRadioButton_Event(void* ptr, void* e)
{
return static_cast<QRadioButton*>(ptr)->event(static_cast<QEvent*>(e));
}
int QRadioButton_HitButton(void* ptr, void* pos)
{
return static_cast<QRadioButton*>(ptr)->hitButton(*static_cast<QPoint*>(pos));
}
int 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 new QSize(static_cast<QSize>(static_cast<QRadioButton*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QRadioButton*>(ptr)->minimumSizeHint()).height());
}
void* QRadioButton_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QRadioButton*>(ptr)->QRadioButton::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QRadioButton*>(ptr)->QRadioButton::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QRadioButton*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QRadioButton*>(ptr)->sizeHint()).height());
}
void* QRadioButton_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QRadioButton*>(ptr)->QRadioButton::sizeHint()).width(), static_cast<QSize>(static_cast<QRadioButton*>(ptr)->QRadioButton::sizeHint()).height());
}
void QRadioButton_DestroyQRadioButton(void* ptr)
{
static_cast<QRadioButton*>(ptr)->~QRadioButton();
}
void QRadioButton_SetChecked(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}
void QRadioButton_SetCheckedDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QRadioButton_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QRadioButton_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QRadioButton*>(ptr)->QRadioButton::setVisible(visible != 0);
}
void QRadioButton_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QRadioButton_SetWindowModifiedDefault(void* ptr, int 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));
}
int QRadioButton_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QRadioButton_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QRadioButton*>(ptr)->focusNextPrevChild(next != 0);
}
int QRadioButton_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QRadioButton*>(ptr)->QRadioButton::focusNextPrevChild(next != 0);
}
int QRadioButton_HasHeightForWidth(void* ptr)
{
return static_cast<QRadioButton*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QRadioButton*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QRadioButton_InputMethodQueryDefault(void* ptr, int 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));
}
int QRadioButton_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QRadioButton*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QRadioButton_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QRadioButton*>(ptr)->QRadioButton::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QRadioButton_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QRadioButton*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QRadioButton_SetHiddenDefault(void* ptr, int 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));
}
int QRadioButton_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QRadioButton*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), e); };
void moveEvent(QMoveEvent * vqm) { callbackQRubberBand_MoveEvent(this, this->objectName().toUtf8().data(), vqm); };
void paintEvent(QPaintEvent * vqp) { callbackQRubberBand_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
void resizeEvent(QResizeEvent * vqr) { callbackQRubberBand_ResizeEvent(this, this->objectName().toUtf8().data(), vqr); };
void showEvent(QShowEvent * e) { callbackQRubberBand_ShowEvent(this, this->objectName().toUtf8().data(), e); };
void actionEvent(QActionEvent * event) { callbackQRubberBand_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQRubberBand_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQRubberBand_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQRubberBand_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQRubberBand_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQRubberBand_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQRubberBand_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQRubberBand_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQRubberBand_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQRubberBand_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQRubberBand_MinimumSizeHint(const_cast<MyQRubberBand*>(this), this->objectName().toUtf8().data())); };
void setEnabled(bool vbo) { callbackQRubberBand_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQRubberBand_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQRubberBand_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQRubberBand_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQRubberBand_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQRubberBand_SizeHint(const_cast<MyQRubberBand*>(this), this->objectName().toUtf8().data())); };
bool close() { return callbackQRubberBand_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQRubberBand_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQRubberBand_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQRubberBand_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQRubberBand_HasHeightForWidth(const_cast<MyQRubberBand*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQRubberBand_HeightForWidth(const_cast<MyQRubberBand*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQRubberBand_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQRubberBand_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQRubberBand_InputMethodQuery(const_cast<MyQRubberBand*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQRubberBand_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQRubberBand_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQRubberBand_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQRubberBand_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQRubberBand_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQRubberBand_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQRubberBand_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQRubberBand_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQRubberBand_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQRubberBand_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQRubberBand_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQRubberBand_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQRubberBand_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQRubberBand_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQRubberBand_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQRubberBand_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQRubberBand_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQRubberBand_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQRubberBand_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQRubberBand_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQRubberBand_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQRubberBand_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQRubberBand_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQRubberBand_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQRubberBand_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQRubberBand_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQRubberBand_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQRubberBand_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQRubberBand_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQRubberBand_MetaObject(const_cast<MyQRubberBand*>(this), this->objectName().toUtf8().data())); };
};
void QRubberBand_SetGeometry(void* ptr, void* rect)
{
static_cast<QRubberBand*>(ptr)->setGeometry(*static_cast<QRect*>(rect));
}
void* QRubberBand_NewQRubberBand(int 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));
}
int 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);
}
int 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 new QSize(static_cast<QSize>(static_cast<QRubberBand*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QRubberBand*>(ptr)->minimumSizeHint()).height());
}
void* QRubberBand_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QRubberBand*>(ptr)->QRubberBand::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QRubberBand*>(ptr)->QRubberBand::minimumSizeHint()).height());
}
void QRubberBand_SetEnabled(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QRubberBand_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QRubberBand_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QRubberBand*>(ptr)->QRubberBand::setVisible(visible != 0);
}
void QRubberBand_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QRubberBand_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QRubberBand*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QRubberBand*>(ptr)->sizeHint()).height());
}
void* QRubberBand_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QRubberBand*>(ptr)->QRubberBand::sizeHint()).width(), static_cast<QSize>(static_cast<QRubberBand*>(ptr)->QRubberBand::sizeHint()).height());
}
int QRubberBand_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QRubberBand_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QRubberBand*>(ptr)->focusNextPrevChild(next != 0);
}
int QRubberBand_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QRubberBand*>(ptr)->QRubberBand::focusNextPrevChild(next != 0);
}
int QRubberBand_HasHeightForWidth(void* ptr)
{
return static_cast<QRubberBand*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QRubberBand*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QRubberBand_InputMethodQueryDefault(void* ptr, int 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));
}
int QRubberBand_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QRubberBand*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QRubberBand_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QRubberBand*>(ptr)->QRubberBand::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QRubberBand_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QRubberBand*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QRubberBand_SetHiddenDefault(void* ptr, int 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));
}
int QRubberBand_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QRubberBand*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), next) != 0; };
void resizeEvent(QResizeEvent * vqr) { callbackQScrollArea_ResizeEvent(this, this->objectName().toUtf8().data(), vqr); };
void scrollContentsBy(int dx, int dy) { callbackQScrollArea_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQScrollArea_SizeHint(const_cast<MyQScrollArea*>(this), this->objectName().toUtf8().data())); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQScrollArea_ViewportSizeHint(const_cast<MyQScrollArea*>(this), this->objectName().toUtf8().data())); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQScrollArea_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQScrollArea_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQScrollArea_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQScrollArea_DropEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQScrollArea_PaintEvent(this, this->objectName().toUtf8().data(), event); };
bool viewportEvent(QEvent * event) { return callbackQScrollArea_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
void contextMenuEvent(QContextMenuEvent * e) { callbackQScrollArea_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
void keyPressEvent(QKeyEvent * e) { callbackQScrollArea_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQScrollArea_MinimumSizeHint(const_cast<MyQScrollArea*>(this), this->objectName().toUtf8().data())); };
void mouseDoubleClickEvent(QMouseEvent * e) { callbackQScrollArea_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), e); };
void mouseMoveEvent(QMouseEvent * e) { callbackQScrollArea_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQScrollArea_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQScrollArea_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void setupViewport(QWidget * viewport) { callbackQScrollArea_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
void wheelEvent(QWheelEvent * e) { callbackQScrollArea_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void changeEvent(QEvent * ev) { callbackQScrollArea_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQScrollArea_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQScrollArea_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQScrollArea_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQScrollArea_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQScrollArea_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQScrollArea_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQScrollArea_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQScrollArea_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQScrollArea_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQScrollArea_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQScrollArea_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQScrollArea_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQScrollArea_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQScrollArea_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQScrollArea_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQScrollArea_HasHeightForWidth(const_cast<MyQScrollArea*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQScrollArea_HeightForWidth(const_cast<MyQScrollArea*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQScrollArea_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQScrollArea_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQScrollArea_InputMethodQuery(const_cast<MyQScrollArea*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQScrollArea_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQScrollArea_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQScrollArea_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQScrollArea_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQScrollArea_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQScrollArea_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQScrollArea_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQScrollArea_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQScrollArea_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQScrollArea_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQScrollArea_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQScrollArea_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQScrollArea_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQScrollArea_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQScrollArea_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQScrollArea_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQScrollArea_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQScrollArea_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQScrollArea_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQScrollArea_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQScrollArea_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQScrollArea_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQScrollArea_MetaObject(const_cast<MyQScrollArea*>(this), this->objectName().toUtf8().data())); };
};
int QScrollArea_Alignment(void* ptr)
{
return static_cast<QScrollArea*>(ptr)->alignment();
}
void QScrollArea_SetAlignment(void* ptr, int 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, int resizable)
{
static_cast<QScrollArea*>(ptr)->setWidgetResizable(resizable != 0);
}
int 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);
}
int QScrollArea_Event(void* ptr, void* e)
{
return static_cast<QScrollArea*>(ptr)->event(static_cast<QEvent*>(e));
}
int QScrollArea_EventFilter(void* ptr, void* o, void* e)
{
return static_cast<QScrollArea*>(ptr)->eventFilter(static_cast<QObject*>(o), static_cast<QEvent*>(e));
}
int QScrollArea_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QScrollArea*>(ptr)->focusNextPrevChild(next != 0);
}
int QScrollArea_FocusNextPrevChildDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QScrollArea*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QScrollArea*>(ptr)->sizeHint()).height());
}
void* QScrollArea_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QScrollArea*>(ptr)->QScrollArea::sizeHint()).width(), static_cast<QSize>(static_cast<QScrollArea*>(ptr)->QScrollArea::sizeHint()).height());
}
void* QScrollArea_TakeWidget(void* ptr)
{
return static_cast<QScrollArea*>(ptr)->takeWidget();
}
void* QScrollArea_ViewportSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QScrollArea*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QScrollArea*>(ptr)->viewportSizeHint()).height());
}
void* QScrollArea_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QScrollArea*>(ptr)->QScrollArea::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QScrollArea*>(ptr)->QScrollArea::viewportSizeHint()).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));
}
int QScrollArea_ViewportEvent(void* ptr, void* event)
{
return static_cast<QScrollArea*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int 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 new QSize(static_cast<QSize>(static_cast<QScrollArea*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QScrollArea*>(ptr)->minimumSizeHint()).height());
}
void* QScrollArea_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QScrollArea*>(ptr)->QScrollArea::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QScrollArea*>(ptr)->QScrollArea::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QScrollArea_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QScrollArea_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QScrollArea*>(ptr)->QScrollArea::setVisible(visible != 0);
}
void QScrollArea_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QScrollArea_SetWindowModifiedDefault(void* ptr, int 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));
}
int QScrollArea_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QScrollArea_HasHeightForWidth(void* ptr)
{
return static_cast<QScrollArea*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QScrollArea*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QScrollArea_InputMethodQueryDefault(void* ptr, int 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();
}
int QScrollArea_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QScrollArea*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QScrollArea_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QScrollArea*>(ptr)->QScrollArea::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QScrollArea_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QScrollArea*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QScrollArea_SetHiddenDefault(void* ptr, int 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, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * vqh) { callbackQScrollBar_HideEvent(this, this->objectName().toUtf8().data(), vqh); };
void mouseMoveEvent(QMouseEvent * e) { callbackQScrollBar_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQScrollBar_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQScrollBar_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void paintEvent(QPaintEvent * vqp) { callbackQScrollBar_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQScrollBar_SizeHint(const_cast<MyQScrollBar*>(this), this->objectName().toUtf8().data())); };
void sliderChange(QAbstractSlider::SliderChange change) { callbackQScrollBar_SliderChange(this, this->objectName().toUtf8().data(), change); };
void wheelEvent(QWheelEvent * event) { callbackQScrollBar_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void setOrientation(Qt::Orientation vqt) { callbackQScrollBar_SetOrientation(this, this->objectName().toUtf8().data(), vqt); };
void setValue(int vin) { callbackQScrollBar_SetValue(this, this->objectName().toUtf8().data(), vin); };
void changeEvent(QEvent * ev) { callbackQScrollBar_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void keyPressEvent(QKeyEvent * ev) { callbackQScrollBar_KeyPressEvent(this, this->objectName().toUtf8().data(), ev); };
void setRange(int min, int max) { callbackQScrollBar_SetRange(this, this->objectName().toUtf8().data(), min, max); };
void actionEvent(QActionEvent * event) { callbackQScrollBar_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQScrollBar_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQScrollBar_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQScrollBar_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQScrollBar_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQScrollBar_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQScrollBar_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQScrollBar_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQScrollBar_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQScrollBar_MinimumSizeHint(const_cast<MyQScrollBar*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQScrollBar_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQScrollBar_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQScrollBar_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQScrollBar_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQScrollBar_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQScrollBar_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQScrollBar_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQScrollBar_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQScrollBar_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQScrollBar_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQScrollBar_HasHeightForWidth(const_cast<MyQScrollBar*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQScrollBar_HeightForWidth(const_cast<MyQScrollBar*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQScrollBar_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQScrollBar_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQScrollBar_InputMethodQuery(const_cast<MyQScrollBar*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQScrollBar_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQScrollBar_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQScrollBar_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQScrollBar_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQScrollBar_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQScrollBar_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQScrollBar_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQScrollBar_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQScrollBar_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQScrollBar_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQScrollBar_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQScrollBar_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQScrollBar_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQScrollBar_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQScrollBar_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQScrollBar_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQScrollBar_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQScrollBar_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQScrollBar_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQScrollBar_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQScrollBar_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQScrollBar_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQScrollBar_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQScrollBar_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQScrollBar_MetaObject(const_cast<MyQScrollBar*>(this), this->objectName().toUtf8().data())); };
};
void* QScrollBar_NewQScrollBar(void* parent)
{
return new MyQScrollBar(static_cast<QWidget*>(parent));
}
void* QScrollBar_NewQScrollBar2(int 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));
}
int 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 new QSize(static_cast<QSize>(static_cast<QScrollBar*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QScrollBar*>(ptr)->sizeHint()).height());
}
void* QScrollBar_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QScrollBar*>(ptr)->QScrollBar::sizeHint()).width(), static_cast<QSize>(static_cast<QScrollBar*>(ptr)->QScrollBar::sizeHint()).height());
}
void QScrollBar_SliderChange(void* ptr, int change)
{
static_cast<QScrollBar*>(ptr)->sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
}
void QScrollBar_SliderChangeDefault(void* ptr, int 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, int vqt)
{
QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setOrientation", Q_ARG(Qt::Orientation, static_cast<Qt::Orientation>(vqt)));
}
void QScrollBar_SetOrientationDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QScrollBar*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QScrollBar*>(ptr)->minimumSizeHint()).height());
}
void* QScrollBar_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QScrollBar*>(ptr)->QScrollBar::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QScrollBar*>(ptr)->QScrollBar::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QScrollBar_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QScrollBar_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QScrollBar*>(ptr)->QScrollBar::setVisible(visible != 0);
}
void QScrollBar_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QScrollBar_SetWindowModifiedDefault(void* ptr, int 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));
}
int QScrollBar_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QScrollBar_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QScrollBar*>(ptr)->focusNextPrevChild(next != 0);
}
int QScrollBar_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QScrollBar*>(ptr)->QScrollBar::focusNextPrevChild(next != 0);
}
int QScrollBar_HasHeightForWidth(void* ptr)
{
return static_cast<QScrollBar*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QScrollBar*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QScrollBar_InputMethodQueryDefault(void* ptr, int 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));
}
int QScrollBar_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QScrollBar*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QScrollBar_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QScrollBar*>(ptr)->QScrollBar::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QScrollBar_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QScrollBar*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QScrollBar_SetHiddenDefault(void* ptr, int 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));
}
int QScrollBar_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QScrollBar*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), new QScrollerProperties(prop)); };
void ensureVisible(const QRectF & rect, qreal xmargin, qreal ymargin) { callbackQScroller_EnsureVisible(this, this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height()), static_cast<double>(xmargin), static_cast<double>(ymargin)); };
void ensureVisible(const QRectF & rect, qreal xmargin, qreal ymargin, int scrollTime) { callbackQScroller_EnsureVisible2(this, this->objectName().toUtf8().data(), new QRectF(static_cast<QRectF>(rect).x(), static_cast<QRectF>(rect).y(), static_cast<QRectF>(rect).width(), static_cast<QRectF>(rect).height()), static_cast<double>(xmargin), static_cast<double>(ymargin), scrollTime); };
void resendPrepareEvent() { callbackQScroller_ResendPrepareEvent(this, this->objectName().toUtf8().data()); };
void scrollTo(const QPointF & pos) { callbackQScroller_ScrollTo(this, this->objectName().toUtf8().data(), new QPointF(static_cast<QPointF>(pos).x(), static_cast<QPointF>(pos).y())); };
void scrollTo(const QPointF & pos, int scrollTime) { callbackQScroller_ScrollTo2(this, this->objectName().toUtf8().data(), new QPointF(static_cast<QPointF>(pos).x(), static_cast<QPointF>(pos).y()), scrollTime); };
void Signal_ScrollerPropertiesChanged(const QScrollerProperties & newProperties) { callbackQScroller_ScrollerPropertiesChanged(this, this->objectName().toUtf8().data(), new QScrollerProperties(newProperties)); };
void Signal_StateChanged(QScroller::State newState) { callbackQScroller_StateChanged(this, this->objectName().toUtf8().data(), newState); };
void timerEvent(QTimerEvent * event) { callbackQScroller_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQScroller_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQScroller_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQScroller_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQScroller_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQScroller_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQScroller_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQScroller_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQScroller_MetaObject(const_cast<MyQScroller*>(this), this->objectName().toUtf8().data())); };
};
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)));
}
int 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, static_cast<double>(xmargin)), Q_ARG(qreal, static_cast<double>(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, static_cast<double>(xmargin)), Q_ARG(qreal, static_cast<double>(ymargin)), Q_ARG(int, scrollTime));
}
void* QScroller_FinalPosition(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QScroller*>(ptr)->finalPosition()).x(), static_cast<QPointF>(static_cast<QScroller*>(ptr)->finalPosition()).y());
}
int QScroller_QScroller_GrabGesture(void* target, int scrollGestureType)
{
return QScroller::grabGesture(static_cast<QObject*>(target), static_cast<QScroller::ScrollerGestureType>(scrollGestureType));
}
int QScroller_QScroller_GrabbedGesture(void* target)
{
return QScroller::grabbedGesture(static_cast<QObject*>(target));
}
int QScroller_HandleInput(void* ptr, int input, void* position, long long timestamp)
{
return static_cast<QScroller*>(ptr)->handleInput(static_cast<QScroller::Input>(input), *static_cast<QPointF*>(position), static_cast<long long>(timestamp));
}
int QScroller_QScroller_HasScroller(void* target)
{
return QScroller::hasScroller(static_cast<QObject*>(target));
}
void* QScroller_PixelPerMeter(void* ptr)
{
return new QPointF(static_cast<QPointF>(static_cast<QScroller*>(ptr)->pixelPerMeter()).x(), static_cast<QPointF>(static_cast<QScroller*>(ptr)->pixelPerMeter()).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(static_cast<double>(first), static_cast<double>(interval));
}
void QScroller_SetSnapPositionsY2(void* ptr, double first, double interval)
{
static_cast<QScroller*>(ptr)->setSnapPositionsY(static_cast<double>(first), static_cast<double>(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, int 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 new QPointF(static_cast<QPointF>(static_cast<QScroller*>(ptr)->velocity()).x(), static_cast<QPointF>(static_cast<QScroller*>(ptr)->velocity()).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));
}
int QScroller_Event(void* ptr, void* e)
{
return static_cast<QScroller*>(ptr)->event(static_cast<QEvent*>(e));
}
int QScroller_EventDefault(void* ptr, void* e)
{
return static_cast<QScroller*>(ptr)->QScroller::event(static_cast<QEvent*>(e));
}
int QScroller_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QScroller*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQScrollerProperties() : QScrollerProperties() {};
MyQScrollerProperties(const QScrollerProperties &sp) : QScrollerProperties(sp) {};
};
void* QScrollerProperties_NewQScrollerProperties()
{
return new MyQScrollerProperties();
}
void* QScrollerProperties_NewQScrollerProperties2(void* sp)
{
return new MyQScrollerProperties(*static_cast<QScrollerProperties*>(sp));
}
void* QScrollerProperties_ScrollMetric(void* ptr, int 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, int 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();
}
char* QScrollerProperties_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQScrollerProperties*>(static_cast<QScrollerProperties*>(ptr))) {
return static_cast<MyQScrollerProperties*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QScrollerProperties_BASE").toUtf8().data();
}
void QScrollerProperties_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQScrollerProperties*>(static_cast<QScrollerProperties*>(ptr))) {
static_cast<MyQScrollerProperties*>(ptr)->setObjectNameAbs(QString(name));
}
}
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, this->objectName().toUtf8().data()); };
void Signal_ActivatedAmbiguously() { callbackQShortcut_ActivatedAmbiguously(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQShortcut_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQShortcut_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQShortcut_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQShortcut_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQShortcut_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQShortcut_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQShortcut_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQShortcut_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQShortcut_MetaObject(const_cast<MyQShortcut*>(this), this->objectName().toUtf8().data())); };
};
int QShortcut_AutoRepeat(void* ptr)
{
return static_cast<QShortcut*>(ptr)->autoRepeat();
}
int QShortcut_Context(void* ptr)
{
return static_cast<QShortcut*>(ptr)->context();
}
int 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, int on)
{
static_cast<QShortcut*>(ptr)->setAutoRepeat(on != 0);
}
void QShortcut_SetContext(void* ptr, int context)
{
static_cast<QShortcut*>(ptr)->setContext(static_cast<Qt::ShortcutContext>(context));
}
void QShortcut_SetEnabled(void* ptr, int 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 static_cast<QShortcut*>(ptr)->whatsThis().toUtf8().data();
}
void* QShortcut_NewQShortcut(void* parent)
{
return new MyQShortcut(static_cast<QWidget*>(parent));
}
void* QShortcut_NewQShortcut2(void* key, void* parent, char* member, char* ambiguousMember, int 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));
}
int QShortcut_Event(void* ptr, void* e)
{
return static_cast<QShortcut*>(ptr)->event(static_cast<QEvent*>(e));
}
int QShortcut_EventDefault(void* ptr, void* e)
{
return static_cast<QShortcut*>(ptr)->QShortcut::event(static_cast<QEvent*>(e));
}
int QShortcut_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QShortcut*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQSizeGrip_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * hideEvent) { callbackQSizeGrip_HideEvent(this, this->objectName().toUtf8().data(), hideEvent); };
void mouseReleaseEvent(QMouseEvent * mouseEvent) { callbackQSizeGrip_MouseReleaseEvent(this, this->objectName().toUtf8().data(), mouseEvent); };
void moveEvent(QMoveEvent * moveEvent) { callbackQSizeGrip_MoveEvent(this, this->objectName().toUtf8().data(), moveEvent); };
void paintEvent(QPaintEvent * event) { callbackQSizeGrip_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setVisible(bool visible) { callbackQSizeGrip_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void showEvent(QShowEvent * showEvent) { callbackQSizeGrip_ShowEvent(this, this->objectName().toUtf8().data(), showEvent); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQSizeGrip_SizeHint(const_cast<MyQSizeGrip*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQSizeGrip_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQSizeGrip_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQSizeGrip_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQSizeGrip_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQSizeGrip_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQSizeGrip_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQSizeGrip_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQSizeGrip_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQSizeGrip_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQSizeGrip_MinimumSizeHint(const_cast<MyQSizeGrip*>(this), this->objectName().toUtf8().data())); };
void setEnabled(bool vbo) { callbackQSizeGrip_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQSizeGrip_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setWindowModified(bool vbo) { callbackQSizeGrip_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQSizeGrip_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void changeEvent(QEvent * event) { callbackQSizeGrip_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQSizeGrip_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQSizeGrip_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQSizeGrip_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQSizeGrip_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQSizeGrip_HasHeightForWidth(const_cast<MyQSizeGrip*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQSizeGrip_HeightForWidth(const_cast<MyQSizeGrip*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQSizeGrip_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQSizeGrip_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQSizeGrip_InputMethodQuery(const_cast<MyQSizeGrip*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQSizeGrip_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQSizeGrip_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQSizeGrip_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQSizeGrip_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQSizeGrip_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQSizeGrip_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQSizeGrip_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQSizeGrip_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQSizeGrip_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQSizeGrip_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQSizeGrip_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQSizeGrip_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQSizeGrip_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQSizeGrip_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQSizeGrip_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQSizeGrip_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQSizeGrip_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQSizeGrip_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQSizeGrip_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQSizeGrip_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQSizeGrip_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQSizeGrip_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQSizeGrip_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQSizeGrip_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQSizeGrip_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQSizeGrip_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSizeGrip_MetaObject(const_cast<MyQSizeGrip*>(this), this->objectName().toUtf8().data())); };
};
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));
}
int QSizeGrip_Event(void* ptr, void* event)
{
return static_cast<QSizeGrip*>(ptr)->event(static_cast<QEvent*>(event));
}
int 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, int visible)
{
static_cast<QSizeGrip*>(ptr)->setVisible(visible != 0);
}
void QSizeGrip_SetVisibleDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QSizeGrip*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QSizeGrip*>(ptr)->sizeHint()).height());
}
void* QSizeGrip_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSizeGrip*>(ptr)->QSizeGrip::sizeHint()).width(), static_cast<QSize>(static_cast<QSizeGrip*>(ptr)->QSizeGrip::sizeHint()).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 new QSize(static_cast<QSize>(static_cast<QSizeGrip*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QSizeGrip*>(ptr)->minimumSizeHint()).height());
}
void* QSizeGrip_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSizeGrip*>(ptr)->QSizeGrip::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QSizeGrip*>(ptr)->QSizeGrip::minimumSizeHint()).height());
}
void QSizeGrip_SetEnabled(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QSizeGrip_SetEnabledDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QSizeGrip_SetWindowModifiedDefault(void* ptr, int 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));
}
int QSizeGrip_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QSizeGrip_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QSizeGrip*>(ptr)->focusNextPrevChild(next != 0);
}
int QSizeGrip_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QSizeGrip*>(ptr)->QSizeGrip::focusNextPrevChild(next != 0);
}
int QSizeGrip_HasHeightForWidth(void* ptr)
{
return static_cast<QSizeGrip*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QSizeGrip*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QSizeGrip_InputMethodQueryDefault(void* ptr, int 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));
}
int QSizeGrip_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QSizeGrip*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QSizeGrip_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QSizeGrip*>(ptr)->QSizeGrip::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QSizeGrip_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QSizeGrip*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QSizeGrip_SetHiddenDefault(void* ptr, int 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(int horizontal, int vertical, int ty)
{
return new QSizePolicy(static_cast<QSizePolicy::Policy>(horizontal), static_cast<QSizePolicy::Policy>(vertical), static_cast<QSizePolicy::ControlType>(ty));
}
int QSizePolicy_ControlType(void* ptr)
{
return static_cast<QSizePolicy*>(ptr)->controlType();
}
int QSizePolicy_ExpandingDirections(void* ptr)
{
return static_cast<QSizePolicy*>(ptr)->expandingDirections();
}
int QSizePolicy_HasHeightForWidth(void* ptr)
{
return static_cast<QSizePolicy*>(ptr)->hasHeightForWidth();
}
int QSizePolicy_HasWidthForHeight(void* ptr)
{
return static_cast<QSizePolicy*>(ptr)->hasWidthForHeight();
}
int QSizePolicy_HorizontalPolicy(void* ptr)
{
return static_cast<QSizePolicy*>(ptr)->horizontalPolicy();
}
int QSizePolicy_HorizontalStretch(void* ptr)
{
return static_cast<QSizePolicy*>(ptr)->horizontalStretch();
}
int QSizePolicy_RetainSizeWhenHidden(void* ptr)
{
return static_cast<QSizePolicy*>(ptr)->retainSizeWhenHidden();
}
void QSizePolicy_SetControlType(void* ptr, int ty)
{
static_cast<QSizePolicy*>(ptr)->setControlType(static_cast<QSizePolicy::ControlType>(ty));
}
void QSizePolicy_SetHeightForWidth(void* ptr, int dependent)
{
static_cast<QSizePolicy*>(ptr)->setHeightForWidth(dependent != 0);
}
void QSizePolicy_SetHorizontalPolicy(void* ptr, int 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, int retainSize)
{
static_cast<QSizePolicy*>(ptr)->setRetainSizeWhenHidden(retainSize != 0);
}
void QSizePolicy_SetVerticalPolicy(void* ptr, int 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, int dependent)
{
static_cast<QSizePolicy*>(ptr)->setWidthForHeight(dependent != 0);
}
void QSizePolicy_Transpose(void* ptr)
{
static_cast<QSizePolicy*>(ptr)->transpose();
}
int 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), this->objectName().toUtf8().data())); };
void mouseMoveEvent(QMouseEvent * ev) { callbackQSlider_MouseMoveEvent(this, this->objectName().toUtf8().data(), ev); };
void mousePressEvent(QMouseEvent * ev) { callbackQSlider_MousePressEvent(this, this->objectName().toUtf8().data(), ev); };
void mouseReleaseEvent(QMouseEvent * ev) { callbackQSlider_MouseReleaseEvent(this, this->objectName().toUtf8().data(), ev); };
void paintEvent(QPaintEvent * ev) { callbackQSlider_PaintEvent(this, this->objectName().toUtf8().data(), ev); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQSlider_SizeHint(const_cast<MyQSlider*>(this), this->objectName().toUtf8().data())); };
void setOrientation(Qt::Orientation vqt) { callbackQSlider_SetOrientation(this, this->objectName().toUtf8().data(), vqt); };
void setValue(int vin) { callbackQSlider_SetValue(this, this->objectName().toUtf8().data(), vin); };
void changeEvent(QEvent * ev) { callbackQSlider_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void keyPressEvent(QKeyEvent * ev) { callbackQSlider_KeyPressEvent(this, this->objectName().toUtf8().data(), ev); };
void setRange(int min, int max) { callbackQSlider_SetRange(this, this->objectName().toUtf8().data(), min, max); };
void sliderChange(QAbstractSlider::SliderChange change) { callbackQSlider_SliderChange(this, this->objectName().toUtf8().data(), change); };
void wheelEvent(QWheelEvent * e) { callbackQSlider_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void actionEvent(QActionEvent * event) { callbackQSlider_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQSlider_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQSlider_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQSlider_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQSlider_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQSlider_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQSlider_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQSlider_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQSlider_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQSlider_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQSlider_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQSlider_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQSlider_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQSlider_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQSlider_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQSlider_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQSlider_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQSlider_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQSlider_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQSlider_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQSlider_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQSlider_HasHeightForWidth(const_cast<MyQSlider*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQSlider_HeightForWidth(const_cast<MyQSlider*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQSlider_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQSlider_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQSlider_InputMethodQuery(const_cast<MyQSlider*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQSlider_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQSlider_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQSlider_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQSlider_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQSlider_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQSlider_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQSlider_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQSlider_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQSlider_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQSlider_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQSlider_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQSlider_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQSlider_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQSlider_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQSlider_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQSlider_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQSlider_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQSlider_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQSlider_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQSlider_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQSlider_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQSlider_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQSlider_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQSlider_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSlider_MetaObject(const_cast<MyQSlider*>(this), this->objectName().toUtf8().data())); };
};
void QSlider_SetTickInterval(void* ptr, int ti)
{
static_cast<QSlider*>(ptr)->setTickInterval(ti);
}
void QSlider_SetTickPosition(void* ptr, int position)
{
static_cast<QSlider*>(ptr)->setTickPosition(static_cast<QSlider::TickPosition>(position));
}
int QSlider_TickInterval(void* ptr)
{
return static_cast<QSlider*>(ptr)->tickInterval();
}
int 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(int orientation, void* parent)
{
return new MyQSlider(static_cast<Qt::Orientation>(orientation), static_cast<QWidget*>(parent));
}
int 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 new QSize(static_cast<QSize>(static_cast<QSlider*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QSlider*>(ptr)->minimumSizeHint()).height());
}
void* QSlider_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSlider*>(ptr)->QSlider::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QSlider*>(ptr)->QSlider::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QSlider*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QSlider*>(ptr)->sizeHint()).height());
}
void* QSlider_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSlider*>(ptr)->QSlider::sizeHint()).width(), static_cast<QSize>(static_cast<QSlider*>(ptr)->QSlider::sizeHint()).height());
}
void QSlider_DestroyQSlider(void* ptr)
{
static_cast<QSlider*>(ptr)->~QSlider();
}
void QSlider_SetOrientation(void* ptr, int vqt)
{
QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setOrientation", Q_ARG(Qt::Orientation, static_cast<Qt::Orientation>(vqt)));
}
void QSlider_SetOrientationDefault(void* ptr, int 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, int change)
{
static_cast<QSlider*>(ptr)->sliderChange(static_cast<QAbstractSlider::SliderChange>(change));
}
void QSlider_SliderChangeDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QSlider_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QSlider_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QSlider*>(ptr)->QSlider::setVisible(visible != 0);
}
void QSlider_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QSlider_SetWindowModifiedDefault(void* ptr, int 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));
}
int QSlider_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QSlider_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QSlider*>(ptr)->focusNextPrevChild(next != 0);
}
int QSlider_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QSlider*>(ptr)->QSlider::focusNextPrevChild(next != 0);
}
int QSlider_HasHeightForWidth(void* ptr)
{
return static_cast<QSlider*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QSlider*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QSlider_InputMethodQueryDefault(void* ptr, int 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));
}
int QSlider_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QSlider*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QSlider_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QSlider*>(ptr)->QSlider::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QSlider_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QSlider*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QSlider_SetHiddenDefault(void* ptr, int 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));
}
int QSlider_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QSlider*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
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), this->objectNameAbs().toUtf8().data())); };
QRect geometry() const { return *static_cast<QRect*>(callbackQSpacerItem_Geometry(const_cast<MyQSpacerItem*>(this), this->objectNameAbs().toUtf8().data())); };
bool isEmpty() const { return callbackQSpacerItem_IsEmpty(const_cast<MyQSpacerItem*>(this), this->objectNameAbs().toUtf8().data()) != 0; };
QSize maximumSize() const { return *static_cast<QSize*>(callbackQSpacerItem_MaximumSize(const_cast<MyQSpacerItem*>(this), this->objectNameAbs().toUtf8().data())); };
QSize minimumSize() const { return *static_cast<QSize*>(callbackQSpacerItem_MinimumSize(const_cast<MyQSpacerItem*>(this), this->objectNameAbs().toUtf8().data())); };
void setGeometry(const QRect & r) { callbackQSpacerItem_SetGeometry(this, this->objectNameAbs().toUtf8().data(), new QRect(static_cast<QRect>(r).x(), static_cast<QRect>(r).y(), static_cast<QRect>(r).width(), static_cast<QRect>(r).height())); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQSpacerItem_SizeHint(const_cast<MyQSpacerItem*>(this), this->objectNameAbs().toUtf8().data())); };
QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQSpacerItem_SpacerItem(this, this->objectNameAbs().toUtf8().data())); };
QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQSpacerItem_ControlTypes(const_cast<MyQSpacerItem*>(this), this->objectNameAbs().toUtf8().data())); };
bool hasHeightForWidth() const { return callbackQSpacerItem_HasHeightForWidth(const_cast<MyQSpacerItem*>(this), this->objectNameAbs().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQSpacerItem_HeightForWidth(const_cast<MyQSpacerItem*>(this), this->objectNameAbs().toUtf8().data(), w); };
void invalidate() { callbackQSpacerItem_Invalidate(this, this->objectNameAbs().toUtf8().data()); };
QLayout * layout() { return static_cast<QLayout*>(callbackQSpacerItem_Layout(this, this->objectNameAbs().toUtf8().data())); };
int minimumHeightForWidth(int w) const { return callbackQSpacerItem_MinimumHeightForWidth(const_cast<MyQSpacerItem*>(this), this->objectNameAbs().toUtf8().data(), w); };
QWidget * widget() { return static_cast<QWidget*>(callbackQSpacerItem_Widget(this, this->objectNameAbs().toUtf8().data())); };
};
void* QSpacerItem_NewQSpacerItem(int w, int h, int hPolicy, int 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, int hPolicy, int vPolicy)
{
static_cast<QSpacerItem*>(ptr)->changeSize(w, h, static_cast<QSizePolicy::Policy>(hPolicy), static_cast<QSizePolicy::Policy>(vPolicy));
}
int QSpacerItem_ExpandingDirections(void* ptr)
{
return static_cast<QSpacerItem*>(ptr)->expandingDirections();
}
int QSpacerItem_ExpandingDirectionsDefault(void* ptr)
{
return static_cast<QSpacerItem*>(ptr)->QSpacerItem::expandingDirections();
}
void* QSpacerItem_Geometry(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QSpacerItem*>(ptr)->geometry()).x(), static_cast<QRect>(static_cast<QSpacerItem*>(ptr)->geometry()).y(), static_cast<QRect>(static_cast<QSpacerItem*>(ptr)->geometry()).width(), static_cast<QRect>(static_cast<QSpacerItem*>(ptr)->geometry()).height());
}
void* QSpacerItem_GeometryDefault(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QSpacerItem*>(ptr)->QSpacerItem::geometry()).x(), static_cast<QRect>(static_cast<QSpacerItem*>(ptr)->QSpacerItem::geometry()).y(), static_cast<QRect>(static_cast<QSpacerItem*>(ptr)->QSpacerItem::geometry()).width(), static_cast<QRect>(static_cast<QSpacerItem*>(ptr)->QSpacerItem::geometry()).height());
}
int QSpacerItem_IsEmpty(void* ptr)
{
return static_cast<QSpacerItem*>(ptr)->isEmpty();
}
int QSpacerItem_IsEmptyDefault(void* ptr)
{
return static_cast<QSpacerItem*>(ptr)->QSpacerItem::isEmpty();
}
void* QSpacerItem_MaximumSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSpacerItem*>(ptr)->maximumSize()).width(), static_cast<QSize>(static_cast<QSpacerItem*>(ptr)->maximumSize()).height());
}
void* QSpacerItem_MaximumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSpacerItem*>(ptr)->QSpacerItem::maximumSize()).width(), static_cast<QSize>(static_cast<QSpacerItem*>(ptr)->QSpacerItem::maximumSize()).height());
}
void* QSpacerItem_MinimumSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSpacerItem*>(ptr)->minimumSize()).width(), static_cast<QSize>(static_cast<QSpacerItem*>(ptr)->minimumSize()).height());
}
void* QSpacerItem_MinimumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSpacerItem*>(ptr)->QSpacerItem::minimumSize()).width(), static_cast<QSize>(static_cast<QSpacerItem*>(ptr)->QSpacerItem::minimumSize()).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 new QSize(static_cast<QSize>(static_cast<QSpacerItem*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QSpacerItem*>(ptr)->sizeHint()).height());
}
void* QSpacerItem_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSpacerItem*>(ptr)->QSpacerItem::sizeHint()).width(), static_cast<QSize>(static_cast<QSpacerItem*>(ptr)->QSpacerItem::sizeHint()).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();
}
char* QSpacerItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQSpacerItem*>(static_cast<QSpacerItem*>(ptr))) {
return static_cast<MyQSpacerItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QSpacerItem_BASE").toUtf8().data();
}
void QSpacerItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQSpacerItem*>(static_cast<QSpacerItem*>(ptr))) {
static_cast<MyQSpacerItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
int QSpacerItem_ControlTypes(void* ptr)
{
return static_cast<QSpacerItem*>(ptr)->controlTypes();
}
int QSpacerItem_ControlTypesDefault(void* ptr)
{
return static_cast<QSpacerItem*>(ptr)->QSpacerItem::controlTypes();
}
int QSpacerItem_HasHeightForWidth(void* ptr)
{
return static_cast<QSpacerItem*>(ptr)->hasHeightForWidth();
}
int 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, this->objectName().toUtf8().data(), val); };
int valueFromText(const QString & text) const { return callbackQSpinBox_ValueFromText(const_cast<MyQSpinBox*>(this), this->objectName().toUtf8().data(), text.toUtf8().data()); };
void fixup(QString & input) const { callbackQSpinBox_Fixup(const_cast<MyQSpinBox*>(this), this->objectName().toUtf8().data(), input.toUtf8().data()); };
QString textFromValue(int value) const { return QString(callbackQSpinBox_TextFromValue(const_cast<MyQSpinBox*>(this), this->objectName().toUtf8().data(), value)); };
QValidator::State validate(QString & text, int & pos) const { return static_cast<QValidator::State>(callbackQSpinBox_Validate(const_cast<MyQSpinBox*>(this), this->objectName().toUtf8().data(), text.toUtf8().data(), pos)); };
void Signal_ValueChanged2(const QString & text) { callbackQSpinBox_ValueChanged2(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void Signal_ValueChanged(int i) { callbackQSpinBox_ValueChanged(this, this->objectName().toUtf8().data(), i); };
void changeEvent(QEvent * event) { callbackQSpinBox_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
void clear() { callbackQSpinBox_Clear(this, this->objectName().toUtf8().data()); };
void closeEvent(QCloseEvent * event) { callbackQSpinBox_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQSpinBox_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQSpinBox_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQSpinBox_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQSpinBox_HideEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQSpinBox_InputMethodQuery(const_cast<MyQSpinBox*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQSpinBox_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQSpinBox_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQSpinBox_MinimumSizeHint(const_cast<MyQSpinBox*>(this), this->objectName().toUtf8().data())); };
void mouseMoveEvent(QMouseEvent * event) { callbackQSpinBox_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQSpinBox_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQSpinBox_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQSpinBox_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void resizeEvent(QResizeEvent * event) { callbackQSpinBox_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void selectAll() { callbackQSpinBox_SelectAll(this, this->objectName().toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQSpinBox_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQSpinBox_SizeHint(const_cast<MyQSpinBox*>(this), this->objectName().toUtf8().data())); };
void stepBy(int steps) { callbackQSpinBox_StepBy(this, this->objectName().toUtf8().data(), steps); };
void stepDown() { callbackQSpinBox_StepDown(this, this->objectName().toUtf8().data()); };
StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQSpinBox_StepEnabled(const_cast<MyQSpinBox*>(this), this->objectName().toUtf8().data())); };
void stepUp() { callbackQSpinBox_StepUp(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQSpinBox_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void actionEvent(QActionEvent * event) { callbackQSpinBox_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQSpinBox_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQSpinBox_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQSpinBox_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQSpinBox_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQSpinBox_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQSpinBox_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQSpinBox_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQSpinBox_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQSpinBox_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQSpinBox_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQSpinBox_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQSpinBox_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQSpinBox_Close(this, this->objectName().toUtf8().data()) != 0; };
bool focusNextPrevChild(bool next) { return callbackQSpinBox_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQSpinBox_HasHeightForWidth(const_cast<MyQSpinBox*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQSpinBox_HeightForWidth(const_cast<MyQSpinBox*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQSpinBox_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQSpinBox_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQSpinBox_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQSpinBox_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQSpinBox_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQSpinBox_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQSpinBox_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQSpinBox_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQSpinBox_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQSpinBox_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQSpinBox_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQSpinBox_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQSpinBox_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQSpinBox_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQSpinBox_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQSpinBox_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQSpinBox_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQSpinBox_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQSpinBox_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQSpinBox_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQSpinBox_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQSpinBox_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQSpinBox_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQSpinBox_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSpinBox_MetaObject(const_cast<MyQSpinBox*>(this), this->objectName().toUtf8().data())); };
};
char* QSpinBox_CleanText(void* ptr)
{
return static_cast<QSpinBox*>(ptr)->cleanText().toUtf8().data();
}
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 static_cast<QSpinBox*>(ptr)->prefix().toUtf8().data();
}
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 static_cast<QSpinBox*>(ptr)->suffix().toUtf8().data();
}
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));
}
int QSpinBox_Event(void* ptr, void* event)
{
return static_cast<QSpinBox*>(ptr)->event(static_cast<QEvent*>(event));
}
void QSpinBox_SetRange(void* ptr, int minimum, int maximum)
{
static_cast<QSpinBox*>(ptr)->setRange(minimum, maximum);
}
char* QSpinBox_TextFromValue(void* ptr, int value)
{
return static_cast<QSpinBox*>(ptr)->textFromValue(value).toUtf8().data();
}
char* QSpinBox_TextFromValueDefault(void* ptr, int value)
{
return static_cast<QSpinBox*>(ptr)->QSpinBox::textFromValue(value).toUtf8().data();
}
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, int query)
{
return new QVariant(static_cast<QSpinBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QSpinBox_InputMethodQueryDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QSpinBox*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QSpinBox*>(ptr)->minimumSizeHint()).height());
}
void* QSpinBox_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSpinBox*>(ptr)->QSpinBox::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QSpinBox*>(ptr)->QSpinBox::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QSpinBox*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QSpinBox*>(ptr)->sizeHint()).height());
}
void* QSpinBox_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSpinBox*>(ptr)->QSpinBox::sizeHint()).width(), static_cast<QSize>(static_cast<QSpinBox*>(ptr)->QSpinBox::sizeHint()).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();
}
int QSpinBox_StepEnabled(void* ptr)
{
return static_cast<QSpinBox*>(ptr)->stepEnabled();
}
int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QSpinBox_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QSpinBox_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QSpinBox*>(ptr)->QSpinBox::setVisible(visible != 0);
}
void QSpinBox_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QSpinBox_SetWindowModifiedDefault(void* ptr, int 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));
}
int QSpinBox_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QSpinBox_CloseDefault(void* ptr)
{
return static_cast<QSpinBox*>(ptr)->QSpinBox::close();
}
int QSpinBox_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QSpinBox*>(ptr)->focusNextPrevChild(next != 0);
}
int QSpinBox_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QSpinBox*>(ptr)->QSpinBox::focusNextPrevChild(next != 0);
}
int QSpinBox_HasHeightForWidth(void* ptr)
{
return static_cast<QSpinBox*>(ptr)->hasHeightForWidth();
}
int 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));
}
int QSpinBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QSpinBox*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QSpinBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QSpinBox*>(ptr)->QSpinBox::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QSpinBox_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QSpinBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QSpinBox_SetHiddenDefault(void* ptr, int 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));
}
int QSpinBox_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QSpinBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data()); };
void drawContents(QPainter * painter) { callbackQSplashScreen_DrawContents(this, this->objectName().toUtf8().data(), painter); };
void Signal_MessageChanged(const QString & message) { callbackQSplashScreen_MessageChanged(this, this->objectName().toUtf8().data(), message.toUtf8().data()); };
void mousePressEvent(QMouseEvent * vqm) { callbackQSplashScreen_MousePressEvent(this, this->objectName().toUtf8().data(), vqm); };
void showMessage(const QString & message, int alignment, const QColor & color) { callbackQSplashScreen_ShowMessage(this, this->objectName().toUtf8().data(), message.toUtf8().data(), alignment, new QColor(color)); };
void actionEvent(QActionEvent * event) { callbackQSplashScreen_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQSplashScreen_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQSplashScreen_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQSplashScreen_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQSplashScreen_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQSplashScreen_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQSplashScreen_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQSplashScreen_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQSplashScreen_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQSplashScreen_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQSplashScreen_MinimumSizeHint(const_cast<MyQSplashScreen*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQSplashScreen_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQSplashScreen_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQSplashScreen_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQSplashScreen_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQSplashScreen_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQSplashScreen_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQSplashScreen_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQSplashScreen_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQSplashScreen_SizeHint(const_cast<MyQSplashScreen*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * event) { callbackQSplashScreen_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQSplashScreen_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQSplashScreen_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQSplashScreen_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQSplashScreen_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQSplashScreen_HasHeightForWidth(const_cast<MyQSplashScreen*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQSplashScreen_HeightForWidth(const_cast<MyQSplashScreen*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQSplashScreen_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQSplashScreen_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQSplashScreen_InputMethodQuery(const_cast<MyQSplashScreen*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQSplashScreen_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQSplashScreen_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQSplashScreen_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQSplashScreen_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQSplashScreen_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQSplashScreen_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQSplashScreen_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQSplashScreen_Raise(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQSplashScreen_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQSplashScreen_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQSplashScreen_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQSplashScreen_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQSplashScreen_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQSplashScreen_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQSplashScreen_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQSplashScreen_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQSplashScreen_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQSplashScreen_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQSplashScreen_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQSplashScreen_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQSplashScreen_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQSplashScreen_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQSplashScreen_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQSplashScreen_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQSplashScreen_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQSplashScreen_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQSplashScreen_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQSplashScreen_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSplashScreen_MetaObject(const_cast<MyQSplashScreen*>(this), this->objectName().toUtf8().data())); };
};
void* QSplashScreen_NewQSplashScreen2(void* parent, void* pixmap, int f)
{
return new MyQSplashScreen(static_cast<QWidget*>(parent), *static_cast<QPixmap*>(pixmap), static_cast<Qt::WindowType>(f));
}
void* QSplashScreen_NewQSplashScreen(void* pixmap, int 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));
}
int 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 static_cast<QSplashScreen*>(ptr)->message().toUtf8().data();
}
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_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 new QSize(static_cast<QSize>(static_cast<QSplashScreen*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QSplashScreen*>(ptr)->minimumSizeHint()).height());
}
void* QSplashScreen_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSplashScreen*>(ptr)->QSplashScreen::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QSplashScreen*>(ptr)->QSplashScreen::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QSplashScreen_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QSplashScreen_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QSplashScreen*>(ptr)->QSplashScreen::setVisible(visible != 0);
}
void QSplashScreen_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QSplashScreen_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QSplashScreen*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QSplashScreen*>(ptr)->sizeHint()).height());
}
void* QSplashScreen_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSplashScreen*>(ptr)->QSplashScreen::sizeHint()).width(), static_cast<QSize>(static_cast<QSplashScreen*>(ptr)->QSplashScreen::sizeHint()).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));
}
int QSplashScreen_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QSplashScreen_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QSplashScreen*>(ptr)->focusNextPrevChild(next != 0);
}
int QSplashScreen_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QSplashScreen*>(ptr)->QSplashScreen::focusNextPrevChild(next != 0);
}
int QSplashScreen_HasHeightForWidth(void* ptr)
{
return static_cast<QSplashScreen*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QSplashScreen*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QSplashScreen_InputMethodQueryDefault(void* ptr, int 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));
}
int QSplashScreen_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QSplashScreen*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QSplashScreen_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QSplashScreen*>(ptr)->QSplashScreen::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QSplashScreen_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QSplashScreen*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QSplashScreen_SetHiddenDefault(void* ptr, int 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));
}
int QSplashScreen_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QSplashScreen*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), ev); };
QSplitterHandle * createHandle() { return static_cast<QSplitterHandle*>(callbackQSplitter_CreateHandle(this, this->objectName().toUtf8().data())); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQSplitter_MinimumSizeHint(const_cast<MyQSplitter*>(this), this->objectName().toUtf8().data())); };
void resizeEvent(QResizeEvent * vqr) { callbackQSplitter_ResizeEvent(this, this->objectName().toUtf8().data(), vqr); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQSplitter_SizeHint(const_cast<MyQSplitter*>(this), this->objectName().toUtf8().data())); };
void Signal_SplitterMoved(int pos, int index) { callbackQSplitter_SplitterMoved(this, this->objectName().toUtf8().data(), pos, index); };
void paintEvent(QPaintEvent * vqp) { callbackQSplitter_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
void actionEvent(QActionEvent * event) { callbackQSplitter_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQSplitter_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQSplitter_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQSplitter_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQSplitter_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQSplitter_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQSplitter_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQSplitter_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQSplitter_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQSplitter_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQSplitter_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQSplitter_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQSplitter_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQSplitter_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQSplitter_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQSplitter_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQSplitter_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQSplitter_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQSplitter_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQSplitter_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQSplitter_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQSplitter_HasHeightForWidth(const_cast<MyQSplitter*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQSplitter_HeightForWidth(const_cast<MyQSplitter*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQSplitter_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQSplitter_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQSplitter_InputMethodQuery(const_cast<MyQSplitter*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQSplitter_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQSplitter_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQSplitter_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQSplitter_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQSplitter_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQSplitter_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQSplitter_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQSplitter_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQSplitter_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQSplitter_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQSplitter_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQSplitter_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQSplitter_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQSplitter_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQSplitter_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQSplitter_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQSplitter_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQSplitter_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQSplitter_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQSplitter_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQSplitter_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQSplitter_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQSplitter_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQSplitter_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQSplitter_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQSplitter_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQSplitter_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQSplitter_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSplitter_MetaObject(const_cast<MyQSplitter*>(this), this->objectName().toUtf8().data())); };
};
int 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));
}
int QSplitter_OpaqueResize(void* ptr)
{
return static_cast<QSplitter*>(ptr)->opaqueResize();
}
int QSplitter_Orientation(void* ptr)
{
return static_cast<QSplitter*>(ptr)->orientation();
}
void QSplitter_SetChildrenCollapsible(void* ptr, int 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, int opaque)
{
static_cast<QSplitter*>(ptr)->setOpaqueResize(opaque != 0);
}
void QSplitter_SetOrientation(void* ptr, int 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(int 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();
}
int 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));
}
int QSplitter_IsCollapsible(void* ptr, int index)
{
return static_cast<QSplitter*>(ptr)->isCollapsible(index);
}
void* QSplitter_MinimumSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSplitter*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QSplitter*>(ptr)->minimumSizeHint()).height());
}
void* QSplitter_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSplitter*>(ptr)->QSplitter::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QSplitter*>(ptr)->QSplitter::minimumSizeHint()).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));
}
int QSplitter_RestoreState(void* ptr, char* state)
{
return static_cast<QSplitter*>(ptr)->restoreState(QByteArray(state));
}
char* QSplitter_SaveState(void* ptr)
{
return QString(static_cast<QSplitter*>(ptr)->saveState()).toUtf8().data();
}
void QSplitter_SetCollapsible(void* ptr, int index, int 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 new QSize(static_cast<QSize>(static_cast<QSplitter*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QSplitter*>(ptr)->sizeHint()).height());
}
void* QSplitter_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSplitter*>(ptr)->QSplitter::sizeHint()).width(), static_cast<QSize>(static_cast<QSplitter*>(ptr)->QSplitter::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QSplitter_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QSplitter_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QSplitter*>(ptr)->QSplitter::setVisible(visible != 0);
}
void QSplitter_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QSplitter_SetWindowModifiedDefault(void* ptr, int 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));
}
int QSplitter_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QSplitter_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QSplitter*>(ptr)->focusNextPrevChild(next != 0);
}
int QSplitter_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QSplitter*>(ptr)->QSplitter::focusNextPrevChild(next != 0);
}
int QSplitter_HasHeightForWidth(void* ptr)
{
return static_cast<QSplitter*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QSplitter*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QSplitter_InputMethodQueryDefault(void* ptr, int 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));
}
int QSplitter_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QSplitter*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QSplitter_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QSplitter*>(ptr)->QSplitter::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QSplitter_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QSplitter*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QSplitter_SetHiddenDefault(void* ptr, int 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));
}
int QSplitter_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QSplitter*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQSplitterHandle_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQSplitterHandle_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void paintEvent(QPaintEvent * vqp) { callbackQSplitterHandle_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
void resizeEvent(QResizeEvent * event) { callbackQSplitterHandle_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQSplitterHandle_SizeHint(const_cast<MyQSplitterHandle*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQSplitterHandle_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQSplitterHandle_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQSplitterHandle_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQSplitterHandle_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQSplitterHandle_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQSplitterHandle_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQSplitterHandle_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQSplitterHandle_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQSplitterHandle_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQSplitterHandle_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQSplitterHandle_MinimumSizeHint(const_cast<MyQSplitterHandle*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQSplitterHandle_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQSplitterHandle_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQSplitterHandle_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQSplitterHandle_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQSplitterHandle_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQSplitterHandle_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQSplitterHandle_ShowEvent(this, this->objectName().toUtf8().data(), event); };
void changeEvent(QEvent * event) { callbackQSplitterHandle_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQSplitterHandle_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQSplitterHandle_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQSplitterHandle_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQSplitterHandle_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQSplitterHandle_HasHeightForWidth(const_cast<MyQSplitterHandle*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQSplitterHandle_HeightForWidth(const_cast<MyQSplitterHandle*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQSplitterHandle_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQSplitterHandle_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQSplitterHandle_InputMethodQuery(const_cast<MyQSplitterHandle*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQSplitterHandle_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQSplitterHandle_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQSplitterHandle_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQSplitterHandle_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQSplitterHandle_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQSplitterHandle_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQSplitterHandle_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQSplitterHandle_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQSplitterHandle_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQSplitterHandle_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQSplitterHandle_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQSplitterHandle_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQSplitterHandle_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQSplitterHandle_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQSplitterHandle_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQSplitterHandle_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQSplitterHandle_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQSplitterHandle_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQSplitterHandle_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQSplitterHandle_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQSplitterHandle_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQSplitterHandle_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQSplitterHandle_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQSplitterHandle_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQSplitterHandle_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQSplitterHandle_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSplitterHandle_MetaObject(const_cast<MyQSplitterHandle*>(this), this->objectName().toUtf8().data())); };
};
void* QSplitterHandle_NewQSplitterHandle(int 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);
}
int 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);
}
int QSplitterHandle_OpaqueResize(void* ptr)
{
return static_cast<QSplitterHandle*>(ptr)->opaqueResize();
}
int 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, int orientation)
{
static_cast<QSplitterHandle*>(ptr)->setOrientation(static_cast<Qt::Orientation>(orientation));
}
void* QSplitterHandle_SizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSplitterHandle*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QSplitterHandle*>(ptr)->sizeHint()).height());
}
void* QSplitterHandle_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::sizeHint()).width(), static_cast<QSize>(static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::sizeHint()).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 new QSize(static_cast<QSize>(static_cast<QSplitterHandle*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QSplitterHandle*>(ptr)->minimumSizeHint()).height());
}
void* QSplitterHandle_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QSplitterHandle_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QSplitterHandle_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::setVisible(visible != 0);
}
void QSplitterHandle_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QSplitterHandle_SetWindowModifiedDefault(void* ptr, int 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));
}
int QSplitterHandle_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QSplitterHandle_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QSplitterHandle*>(ptr)->focusNextPrevChild(next != 0);
}
int QSplitterHandle_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::focusNextPrevChild(next != 0);
}
int QSplitterHandle_HasHeightForWidth(void* ptr)
{
return static_cast<QSplitterHandle*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QSplitterHandle*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QSplitterHandle_InputMethodQueryDefault(void* ptr, int 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));
}
int QSplitterHandle_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QSplitterHandle*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QSplitterHandle_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QSplitterHandle*>(ptr)->QSplitterHandle::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QSplitterHandle_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QSplitterHandle*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QSplitterHandle_SetHiddenDefault(void* ptr, int 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));
}
int QSplitterHandle_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QSplitterHandle*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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), this->objectName().toUtf8().data()); };
void setCurrentIndex(int index) { callbackQStackedLayout_SetCurrentIndex(this, this->objectName().toUtf8().data(), index); };
void setCurrentWidget(QWidget * widget) { callbackQStackedLayout_SetCurrentWidget(this, this->objectName().toUtf8().data(), widget); };
void addItem(QLayoutItem * item) { callbackQStackedLayout_AddItem(this, this->objectName().toUtf8().data(), item); };
void Signal_CurrentChanged(int index) { callbackQStackedLayout_CurrentChanged(this, this->objectName().toUtf8().data(), index); };
bool hasHeightForWidth() const { return callbackQStackedLayout_HasHeightForWidth(const_cast<MyQStackedLayout*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int width) const { return callbackQStackedLayout_HeightForWidth(const_cast<MyQStackedLayout*>(this), this->objectName().toUtf8().data(), width); };
QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQStackedLayout_ItemAt(const_cast<MyQStackedLayout*>(this), this->objectName().toUtf8().data(), index)); };
QSize minimumSize() const { return *static_cast<QSize*>(callbackQStackedLayout_MinimumSize(const_cast<MyQStackedLayout*>(this), this->objectName().toUtf8().data())); };
void setGeometry(const QRect & rect) { callbackQStackedLayout_SetGeometry(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height())); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQStackedLayout_SizeHint(const_cast<MyQStackedLayout*>(this), this->objectName().toUtf8().data())); };
QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQStackedLayout_TakeAt(this, this->objectName().toUtf8().data(), index)); };
void Signal_WidgetRemoved(int index) { callbackQStackedLayout_WidgetRemoved(this, this->objectName().toUtf8().data(), index); };
QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQStackedLayout_ControlTypes(const_cast<MyQStackedLayout*>(this), this->objectName().toUtf8().data())); };
Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQStackedLayout_ExpandingDirections(const_cast<MyQStackedLayout*>(this), this->objectName().toUtf8().data())); };
QRect geometry() const { return *static_cast<QRect*>(callbackQStackedLayout_Geometry(const_cast<MyQStackedLayout*>(this), this->objectName().toUtf8().data())); };
int indexOf(QWidget * widget) const { return callbackQStackedLayout_IndexOf(const_cast<MyQStackedLayout*>(this), this->objectName().toUtf8().data(), widget); };
void invalidate() { callbackQStackedLayout_Invalidate(this, this->objectName().toUtf8().data()); };
bool isEmpty() const { return callbackQStackedLayout_IsEmpty(const_cast<MyQStackedLayout*>(this), this->objectName().toUtf8().data()) != 0; };
QLayout * layout() { return static_cast<QLayout*>(callbackQStackedLayout_Layout(this, this->objectName().toUtf8().data())); };
QSize maximumSize() const { return *static_cast<QSize*>(callbackQStackedLayout_MaximumSize(const_cast<MyQStackedLayout*>(this), this->objectName().toUtf8().data())); };
void timerEvent(QTimerEvent * event) { callbackQStackedLayout_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQStackedLayout_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQStackedLayout_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQStackedLayout_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQStackedLayout_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQStackedLayout_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQStackedLayout_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStackedLayout_MetaObject(const_cast<MyQStackedLayout*>(this), this->objectName().toUtf8().data())); };
int minimumHeightForWidth(int w) const { return callbackQStackedLayout_MinimumHeightForWidth(const_cast<MyQStackedLayout*>(this), this->objectName().toUtf8().data(), w); };
QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQStackedLayout_SpacerItem(this, this->objectName().toUtf8().data())); };
};
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, int stackingMode)
{
static_cast<QStackedLayout*>(ptr)->setStackingMode(static_cast<QStackedLayout::StackingMode>(stackingMode));
}
int 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();
}
int QStackedLayout_HasHeightForWidth(void* ptr)
{
return static_cast<QStackedLayout*>(ptr)->hasHeightForWidth();
}
int 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 new QSize(static_cast<QSize>(static_cast<QStackedLayout*>(ptr)->minimumSize()).width(), static_cast<QSize>(static_cast<QStackedLayout*>(ptr)->minimumSize()).height());
}
void* QStackedLayout_MinimumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QStackedLayout*>(ptr)->QStackedLayout::minimumSize()).width(), static_cast<QSize>(static_cast<QStackedLayout*>(ptr)->QStackedLayout::minimumSize()).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 new QSize(static_cast<QSize>(static_cast<QStackedLayout*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QStackedLayout*>(ptr)->sizeHint()).height());
}
void* QStackedLayout_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QStackedLayout*>(ptr)->QStackedLayout::sizeHint()).width(), static_cast<QSize>(static_cast<QStackedLayout*>(ptr)->QStackedLayout::sizeHint()).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();
}
int QStackedLayout_ControlTypes(void* ptr)
{
return static_cast<QStackedLayout*>(ptr)->controlTypes();
}
int QStackedLayout_ControlTypesDefault(void* ptr)
{
return static_cast<QStackedLayout*>(ptr)->QStackedLayout::controlTypes();
}
int QStackedLayout_ExpandingDirections(void* ptr)
{
return static_cast<QStackedLayout*>(ptr)->expandingDirections();
}
int QStackedLayout_ExpandingDirectionsDefault(void* ptr)
{
return static_cast<QStackedLayout*>(ptr)->QStackedLayout::expandingDirections();
}
void* QStackedLayout_Geometry(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QStackedLayout*>(ptr)->geometry()).x(), static_cast<QRect>(static_cast<QStackedLayout*>(ptr)->geometry()).y(), static_cast<QRect>(static_cast<QStackedLayout*>(ptr)->geometry()).width(), static_cast<QRect>(static_cast<QStackedLayout*>(ptr)->geometry()).height());
}
void* QStackedLayout_GeometryDefault(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QStackedLayout*>(ptr)->QStackedLayout::geometry()).x(), static_cast<QRect>(static_cast<QStackedLayout*>(ptr)->QStackedLayout::geometry()).y(), static_cast<QRect>(static_cast<QStackedLayout*>(ptr)->QStackedLayout::geometry()).width(), static_cast<QRect>(static_cast<QStackedLayout*>(ptr)->QStackedLayout::geometry()).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();
}
int QStackedLayout_IsEmpty(void* ptr)
{
return static_cast<QStackedLayout*>(ptr)->isEmpty();
}
int 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 new QSize(static_cast<QSize>(static_cast<QStackedLayout*>(ptr)->maximumSize()).width(), static_cast<QSize>(static_cast<QStackedLayout*>(ptr)->maximumSize()).height());
}
void* QStackedLayout_MaximumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QStackedLayout*>(ptr)->QStackedLayout::maximumSize()).width(), static_cast<QSize>(static_cast<QStackedLayout*>(ptr)->QStackedLayout::maximumSize()).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));
}
int QStackedLayout_Event(void* ptr, void* e)
{
return static_cast<QStackedLayout*>(ptr)->event(static_cast<QEvent*>(e));
}
int QStackedLayout_EventDefault(void* ptr, void* e)
{
return static_cast<QStackedLayout*>(ptr)->QStackedLayout::event(static_cast<QEvent*>(e));
}
int QStackedLayout_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QStackedLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), index); };
void setCurrentWidget(QWidget * widget) { callbackQStackedWidget_SetCurrentWidget(this, this->objectName().toUtf8().data(), widget); };
void Signal_CurrentChanged(int index) { callbackQStackedWidget_CurrentChanged(this, this->objectName().toUtf8().data(), index); };
void Signal_WidgetRemoved(int index) { callbackQStackedWidget_WidgetRemoved(this, this->objectName().toUtf8().data(), index); };
void changeEvent(QEvent * ev) { callbackQStackedWidget_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void paintEvent(QPaintEvent * vqp) { callbackQStackedWidget_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQStackedWidget_SizeHint(const_cast<MyQStackedWidget*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQStackedWidget_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQStackedWidget_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQStackedWidget_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQStackedWidget_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQStackedWidget_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQStackedWidget_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQStackedWidget_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQStackedWidget_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQStackedWidget_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQStackedWidget_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQStackedWidget_MinimumSizeHint(const_cast<MyQStackedWidget*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQStackedWidget_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQStackedWidget_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQStackedWidget_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQStackedWidget_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQStackedWidget_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQStackedWidget_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQStackedWidget_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQStackedWidget_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQStackedWidget_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQStackedWidget_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQStackedWidget_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQStackedWidget_HasHeightForWidth(const_cast<MyQStackedWidget*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQStackedWidget_HeightForWidth(const_cast<MyQStackedWidget*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQStackedWidget_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQStackedWidget_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQStackedWidget_InputMethodQuery(const_cast<MyQStackedWidget*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQStackedWidget_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQStackedWidget_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQStackedWidget_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQStackedWidget_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQStackedWidget_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQStackedWidget_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQStackedWidget_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQStackedWidget_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQStackedWidget_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQStackedWidget_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQStackedWidget_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQStackedWidget_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQStackedWidget_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQStackedWidget_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQStackedWidget_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQStackedWidget_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQStackedWidget_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQStackedWidget_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQStackedWidget_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQStackedWidget_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQStackedWidget_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQStackedWidget_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQStackedWidget_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQStackedWidget_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQStackedWidget_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQStackedWidget_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQStackedWidget_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQStackedWidget_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQStackedWidget_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQStackedWidget_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStackedWidget_MetaObject(const_cast<MyQStackedWidget*>(this), this->objectName().toUtf8().data())); };
};
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();
}
int 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 new QSize(static_cast<QSize>(static_cast<QStackedWidget*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QStackedWidget*>(ptr)->sizeHint()).height());
}
void* QStackedWidget_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QStackedWidget*>(ptr)->QStackedWidget::sizeHint()).width(), static_cast<QSize>(static_cast<QStackedWidget*>(ptr)->QStackedWidget::sizeHint()).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 new QSize(static_cast<QSize>(static_cast<QStackedWidget*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QStackedWidget*>(ptr)->minimumSizeHint()).height());
}
void* QStackedWidget_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QStackedWidget*>(ptr)->QStackedWidget::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QStackedWidget*>(ptr)->QStackedWidget::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QStackedWidget_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QStackedWidget_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QStackedWidget*>(ptr)->QStackedWidget::setVisible(visible != 0);
}
void QStackedWidget_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QStackedWidget_SetWindowModifiedDefault(void* ptr, int 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));
}
int QStackedWidget_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QStackedWidget_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QStackedWidget*>(ptr)->focusNextPrevChild(next != 0);
}
int QStackedWidget_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QStackedWidget*>(ptr)->QStackedWidget::focusNextPrevChild(next != 0);
}
int QStackedWidget_HasHeightForWidth(void* ptr)
{
return static_cast<QStackedWidget*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QStackedWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QStackedWidget_InputMethodQueryDefault(void* ptr, int 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));
}
int QStackedWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QStackedWidget*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QStackedWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QStackedWidget*>(ptr)->QStackedWidget::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QStackedWidget_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QStackedWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QStackedWidget_SetHiddenDefault(void* ptr, int 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));
}
int QStackedWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QStackedWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), event); };
void clearMessage() { callbackQStatusBar_ClearMessage(this, this->objectName().toUtf8().data()); };
void Signal_MessageChanged(const QString & message) { callbackQStatusBar_MessageChanged(this, this->objectName().toUtf8().data(), message.toUtf8().data()); };
void resizeEvent(QResizeEvent * e) { callbackQStatusBar_ResizeEvent(this, this->objectName().toUtf8().data(), e); };
void showEvent(QShowEvent * vqs) { callbackQStatusBar_ShowEvent(this, this->objectName().toUtf8().data(), vqs); };
void showMessage(const QString & message, int timeout) { callbackQStatusBar_ShowMessage(this, this->objectName().toUtf8().data(), message.toUtf8().data(), timeout); };
void actionEvent(QActionEvent * event) { callbackQStatusBar_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQStatusBar_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQStatusBar_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQStatusBar_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQStatusBar_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQStatusBar_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQStatusBar_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQStatusBar_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQStatusBar_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQStatusBar_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQStatusBar_MinimumSizeHint(const_cast<MyQStatusBar*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQStatusBar_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQStatusBar_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQStatusBar_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQStatusBar_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQStatusBar_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQStatusBar_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQStatusBar_SizeHint(const_cast<MyQStatusBar*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * event) { callbackQStatusBar_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQStatusBar_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQStatusBar_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQStatusBar_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQStatusBar_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQStatusBar_HasHeightForWidth(const_cast<MyQStatusBar*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQStatusBar_HeightForWidth(const_cast<MyQStatusBar*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQStatusBar_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQStatusBar_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQStatusBar_InputMethodQuery(const_cast<MyQStatusBar*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQStatusBar_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQStatusBar_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQStatusBar_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQStatusBar_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQStatusBar_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQStatusBar_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQStatusBar_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQStatusBar_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQStatusBar_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQStatusBar_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQStatusBar_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQStatusBar_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQStatusBar_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQStatusBar_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQStatusBar_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQStatusBar_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQStatusBar_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQStatusBar_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQStatusBar_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQStatusBar_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQStatusBar_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQStatusBar_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQStatusBar_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQStatusBar_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQStatusBar_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQStatusBar_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQStatusBar_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQStatusBar_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQStatusBar_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStatusBar_MetaObject(const_cast<MyQStatusBar*>(this), this->objectName().toUtf8().data())); };
};
int 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, int 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 static_cast<QStatusBar*>(ptr)->currentMessage().toUtf8().data();
}
int 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_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 new QSize(static_cast<QSize>(static_cast<QStatusBar*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QStatusBar*>(ptr)->minimumSizeHint()).height());
}
void* QStatusBar_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QStatusBar*>(ptr)->QStatusBar::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QStatusBar*>(ptr)->QStatusBar::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QStatusBar_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QStatusBar_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QStatusBar*>(ptr)->QStatusBar::setVisible(visible != 0);
}
void QStatusBar_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QStatusBar_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QStatusBar*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QStatusBar*>(ptr)->sizeHint()).height());
}
void* QStatusBar_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QStatusBar*>(ptr)->QStatusBar::sizeHint()).width(), static_cast<QSize>(static_cast<QStatusBar*>(ptr)->QStatusBar::sizeHint()).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));
}
int QStatusBar_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QStatusBar_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QStatusBar*>(ptr)->focusNextPrevChild(next != 0);
}
int QStatusBar_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QStatusBar*>(ptr)->QStatusBar::focusNextPrevChild(next != 0);
}
int QStatusBar_HasHeightForWidth(void* ptr)
{
return static_cast<QStatusBar*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QStatusBar*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QStatusBar_InputMethodQueryDefault(void* ptr, int 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));
}
int QStatusBar_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QStatusBar*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QStatusBar_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QStatusBar*>(ptr)->QStatusBar::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QStatusBar_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QStatusBar*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QStatusBar_SetHiddenDefault(void* ptr, int 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));
}
int QStatusBar_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QStatusBar*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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()
{
return QStyle::PM_MdiSubWindowMinimizedWidth;
}
int QStyle_PM_HeaderMargin_Type()
{
return QStyle::PM_HeaderMargin;
}
int QStyle_PM_HeaderMarkSize_Type()
{
return QStyle::PM_HeaderMarkSize;
}
int QStyle_PM_HeaderGripMargin_Type()
{
return QStyle::PM_HeaderGripMargin;
}
int QStyle_PM_TabBarTabShiftHorizontal_Type()
{
return QStyle::PM_TabBarTabShiftHorizontal;
}
int QStyle_PM_TabBarTabShiftVertical_Type()
{
return QStyle::PM_TabBarTabShiftVertical;
}
int QStyle_PM_TabBarScrollButtonWidth_Type()
{
return QStyle::PM_TabBarScrollButtonWidth;
}
int QStyle_PM_ToolBarFrameWidth_Type()
{
return QStyle::PM_ToolBarFrameWidth;
}
int QStyle_PM_ToolBarHandleExtent_Type()
{
return QStyle::PM_ToolBarHandleExtent;
}
int QStyle_PM_ToolBarItemSpacing_Type()
{
return QStyle::PM_ToolBarItemSpacing;
}
int QStyle_PM_ToolBarItemMargin_Type()
{
return QStyle::PM_ToolBarItemMargin;
}
int QStyle_PM_ToolBarSeparatorExtent_Type()
{
return QStyle::PM_ToolBarSeparatorExtent;
}
int QStyle_PM_ToolBarExtensionExtent_Type()
{
return QStyle::PM_ToolBarExtensionExtent;
}
int QStyle_PM_SpinBoxSliderHeight_Type()
{
return QStyle::PM_SpinBoxSliderHeight;
}
int QStyle_PM_DefaultTopLevelMargin_Type()
{
return QStyle::PM_DefaultTopLevelMargin;
}
int QStyle_PM_DefaultChildMargin_Type()
{
return QStyle::PM_DefaultChildMargin;
}
int QStyle_PM_DefaultLayoutSpacing_Type()
{
return QStyle::PM_DefaultLayoutSpacing;
}
int QStyle_PM_ToolBarIconSize_Type()
{
return QStyle::PM_ToolBarIconSize;
}
int QStyle_PM_ListViewIconSize_Type()
{
return QStyle::PM_ListViewIconSize;
}
int QStyle_PM_IconViewIconSize_Type()
{
return QStyle::PM_IconViewIconSize;
}
int QStyle_PM_SmallIconSize_Type()
{
return QStyle::PM_SmallIconSize;
}
int QStyle_PM_LargeIconSize_Type()
{
return QStyle::PM_LargeIconSize;
}
int QStyle_PM_FocusFrameVMargin_Type()
{
return QStyle::PM_FocusFrameVMargin;
}
int QStyle_PM_FocusFrameHMargin_Type()
{
return QStyle::PM_FocusFrameHMargin;
}
int QStyle_PM_ToolTipLabelFrameWidth_Type()
{
return QStyle::PM_ToolTipLabelFrameWidth;
}
int QStyle_PM_CheckBoxLabelSpacing_Type()
{
return QStyle::PM_CheckBoxLabelSpacing;
}
int QStyle_PM_TabBarIconSize_Type()
{
return QStyle::PM_TabBarIconSize;
}
int QStyle_PM_SizeGripSize_Type()
{
return QStyle::PM_SizeGripSize;
}
int QStyle_PM_DockWidgetTitleMargin_Type()
{
return QStyle::PM_DockWidgetTitleMargin;
}
int QStyle_PM_MessageBoxIconSize_Type()
{
return QStyle::PM_MessageBoxIconSize;
}
int QStyle_PM_ButtonIconSize_Type()
{
return QStyle::PM_ButtonIconSize;
}
int QStyle_PM_DockWidgetTitleBarButtonMargin_Type()
{
return QStyle::PM_DockWidgetTitleBarButtonMargin;
}
int QStyle_PM_RadioButtonLabelSpacing_Type()
{
return QStyle::PM_RadioButtonLabelSpacing;
}
int QStyle_PM_LayoutLeftMargin_Type()
{
return QStyle::PM_LayoutLeftMargin;
}
int QStyle_PM_LayoutTopMargin_Type()
{
return QStyle::PM_LayoutTopMargin;
}
int QStyle_PM_LayoutRightMargin_Type()
{
return QStyle::PM_LayoutRightMargin;
}
int QStyle_PM_LayoutBottomMargin_Type()
{
return QStyle::PM_LayoutBottomMargin;
}
int QStyle_PM_LayoutHorizontalSpacing_Type()
{
return QStyle::PM_LayoutHorizontalSpacing;
}
int QStyle_PM_LayoutVerticalSpacing_Type()
{
return QStyle::PM_LayoutVerticalSpacing;
}
int QStyle_PM_TabBar_ScrollButtonOverlap_Type()
{
return QStyle::PM_TabBar_ScrollButtonOverlap;
}
int QStyle_PM_TextCursorWidth_Type()
{
return QStyle::PM_TextCursorWidth;
}
int QStyle_PM_TabCloseIndicatorWidth_Type()
{
return QStyle::PM_TabCloseIndicatorWidth;
}
int QStyle_PM_TabCloseIndicatorHeight_Type()
{
return QStyle::PM_TabCloseIndicatorHeight;
}
int QStyle_PM_ScrollView_ScrollBarSpacing_Type()
{
return QStyle::PM_ScrollView_ScrollBarSpacing;
}
int QStyle_PM_ScrollView_ScrollBarOverlap_Type()
{
return QStyle::PM_ScrollView_ScrollBarOverlap;
}
int QStyle_PM_SubMenuOverlap_Type()
{
return QStyle::PM_SubMenuOverlap;
}
int QStyle_PM_TreeViewIndentation_Type()
{
return QStyle::PM_TreeViewIndentation;
}
int QStyle_PM_HeaderDefaultSectionSizeHorizontal_Type()
{
return QStyle::PM_HeaderDefaultSectionSizeHorizontal;
}
int QStyle_PM_HeaderDefaultSectionSizeVertical_Type()
{
return QStyle::PM_HeaderDefaultSectionSizeVertical;
}
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_SH_BlinkCursorWhenTextSelected_Type()
{
return QStyle::SH_BlinkCursorWhenTextSelected;
}
int QStyle_SH_RichText_FullWidthSelection_Type()
{
return QStyle::SH_RichText_FullWidthSelection;
}
int QStyle_SH_Menu_Scrollable_Type()
{
return QStyle::SH_Menu_Scrollable;
}
int QStyle_SH_GroupBox_TextLabelVerticalAlignment_Type()
{
return QStyle::SH_GroupBox_TextLabelVerticalAlignment;
}
int QStyle_SH_GroupBox_TextLabelColor_Type()
{
return QStyle::SH_GroupBox_TextLabelColor;
}
int QStyle_SH_Menu_SloppySubMenus_Type()
{
return QStyle::SH_Menu_SloppySubMenus;
}
int QStyle_SH_Table_GridLineColor_Type()
{
return QStyle::SH_Table_GridLineColor;
}
int QStyle_SH_LineEdit_PasswordCharacter_Type()
{
return QStyle::SH_LineEdit_PasswordCharacter;
}
int QStyle_SH_DialogButtons_DefaultButton_Type()
{
return QStyle::SH_DialogButtons_DefaultButton;
}
int QStyle_SH_ToolBox_SelectedPageTitleBold_Type()
{
return QStyle::SH_ToolBox_SelectedPageTitleBold;
}
int QStyle_SH_TabBar_PreferNoArrows_Type()
{
return QStyle::SH_TabBar_PreferNoArrows;
}
int QStyle_SH_ScrollBar_LeftClickAbsolutePosition_Type()
{
return QStyle::SH_ScrollBar_LeftClickAbsolutePosition;
}
int QStyle_SH_ListViewExpand_SelectMouseType_Type()
{
return QStyle::SH_ListViewExpand_SelectMouseType;
}
int QStyle_SH_UnderlineShortcut_Type()
{
return QStyle::SH_UnderlineShortcut;
}
int QStyle_SH_SpinBox_AnimateButton_Type()
{
return QStyle::SH_SpinBox_AnimateButton;
}
int QStyle_SH_SpinBox_KeyPressAutoRepeatRate_Type()
{
return QStyle::SH_SpinBox_KeyPressAutoRepeatRate;
}
int QStyle_SH_SpinBox_ClickAutoRepeatRate_Type()
{
return QStyle::SH_SpinBox_ClickAutoRepeatRate;
}
int QStyle_SH_Menu_FillScreenWithScroll_Type()
{
return QStyle::SH_Menu_FillScreenWithScroll;
}
int QStyle_SH_ToolTipLabel_Opacity_Type()
{
return QStyle::SH_ToolTipLabel_Opacity;
}
int QStyle_SH_DrawMenuBarSeparator_Type()
{
return QStyle::SH_DrawMenuBarSeparator;
}
int QStyle_SH_TitleBar_ModifyNotification_Type()
{
return QStyle::SH_TitleBar_ModifyNotification;
}
int QStyle_SH_Button_FocusPolicy_Type()
{
return QStyle::SH_Button_FocusPolicy;
}
int QStyle_SH_MessageBox_UseBorderForButtonSpacing_Type()
{
return QStyle::SH_MessageBox_UseBorderForButtonSpacing;
}
int QStyle_SH_TitleBar_AutoRaise_Type()
{
return QStyle::SH_TitleBar_AutoRaise;
}
int QStyle_SH_ToolButton_PopupDelay_Type()
{
return QStyle::SH_ToolButton_PopupDelay;
}
int QStyle_SH_FocusFrame_Mask_Type()
{
return QStyle::SH_FocusFrame_Mask;
}
int QStyle_SH_RubberBand_Mask_Type()
{
return QStyle::SH_RubberBand_Mask;
}
int QStyle_SH_WindowFrame_Mask_Type()
{
return QStyle::SH_WindowFrame_Mask;
}
int QStyle_SH_SpinControls_DisableOnBounds_Type()
{
return QStyle::SH_SpinControls_DisableOnBounds;
}
int QStyle_SH_Dial_BackgroundRole_Type()
{
return QStyle::SH_Dial_BackgroundRole;
}
int QStyle_SH_ComboBox_LayoutDirection_Type()
{
return QStyle::SH_ComboBox_LayoutDirection;
}
int QStyle_SH_ItemView_EllipsisLocation_Type()
{
return QStyle::SH_ItemView_EllipsisLocation;
}
int QStyle_SH_ItemView_ShowDecorationSelected_Type()
{
return QStyle::SH_ItemView_ShowDecorationSelected;
}
int QStyle_SH_ItemView_ActivateItemOnSingleClick_Type()
{
return QStyle::SH_ItemView_ActivateItemOnSingleClick;
}
int QStyle_SH_ScrollBar_ContextMenu_Type()
{
return QStyle::SH_ScrollBar_ContextMenu;
}
int QStyle_SH_ScrollBar_RollBetweenButtons_Type()
{
return QStyle::SH_ScrollBar_RollBetweenButtons;
}
int QStyle_SH_Slider_AbsoluteSetButtons_Type()
{
return QStyle::SH_Slider_AbsoluteSetButtons;
}
int QStyle_SH_Slider_PageSetButtons_Type()
{
return QStyle::SH_Slider_PageSetButtons;
}
int QStyle_SH_Menu_KeyboardSearch_Type()
{
return QStyle::SH_Menu_KeyboardSearch;
}
int QStyle_SH_TabBar_ElideMode_Type()
{
return QStyle::SH_TabBar_ElideMode;
}
int QStyle_SH_DialogButtonLayout_Type()
{
return QStyle::SH_DialogButtonLayout;
}
int QStyle_SH_ComboBox_PopupFrameStyle_Type()
{
return QStyle::SH_ComboBox_PopupFrameStyle;
}
int QStyle_SH_MessageBox_TextInteractionFlags_Type()
{
return QStyle::SH_MessageBox_TextInteractionFlags;
}
int QStyle_SH_DialogButtonBox_ButtonsHaveIcons_Type()
{
return QStyle::SH_DialogButtonBox_ButtonsHaveIcons;
}
int QStyle_SH_SpellCheckUnderlineStyle_Type()
{
return QStyle::SH_SpellCheckUnderlineStyle;
}
int QStyle_SH_MessageBox_CenterButtons_Type()
{
return QStyle::SH_MessageBox_CenterButtons;
}
int QStyle_SH_Menu_SelectionWrap_Type()
{
return QStyle::SH_Menu_SelectionWrap;
}
int QStyle_SH_ItemView_MovementWithoutUpdatingSelection_Type()
{
return QStyle::SH_ItemView_MovementWithoutUpdatingSelection;
}
int QStyle_SH_ToolTip_Mask_Type()
{
return QStyle::SH_ToolTip_Mask;
}
int QStyle_SH_FocusFrame_AboveWidget_Type()
{
return QStyle::SH_FocusFrame_AboveWidget;
}
int QStyle_SH_TextControl_FocusIndicatorTextCharFormat_Type()
{
return QStyle::SH_TextControl_FocusIndicatorTextCharFormat;
}
int QStyle_SH_WizardStyle_Type()
{
return QStyle::SH_WizardStyle;
}
int QStyle_SH_ItemView_ArrowKeysNavigateIntoChildren_Type()
{
return QStyle::SH_ItemView_ArrowKeysNavigateIntoChildren;
}
int QStyle_SH_Menu_Mask_Type()
{
return QStyle::SH_Menu_Mask;
}
int QStyle_SH_Menu_FlashTriggeredItem_Type()
{
return QStyle::SH_Menu_FlashTriggeredItem;
}
int QStyle_SH_Menu_FadeOutOnHide_Type()
{
return QStyle::SH_Menu_FadeOutOnHide;
}
int QStyle_SH_SpinBox_ClickAutoRepeatThreshold_Type()
{
return QStyle::SH_SpinBox_ClickAutoRepeatThreshold;
}
int QStyle_SH_ItemView_PaintAlternatingRowColorsForEmptyArea_Type()
{
return QStyle::SH_ItemView_PaintAlternatingRowColorsForEmptyArea;
}
int QStyle_SH_FormLayoutWrapPolicy_Type()
{
return QStyle::SH_FormLayoutWrapPolicy;
}
int QStyle_SH_TabWidget_DefaultTabPosition_Type()
{
return QStyle::SH_TabWidget_DefaultTabPosition;
}
int QStyle_SH_ToolBar_Movable_Type()
{
return QStyle::SH_ToolBar_Movable;
}
int QStyle_SH_FormLayoutFieldGrowthPolicy_Type()
{
return QStyle::SH_FormLayoutFieldGrowthPolicy;
}
int QStyle_SH_FormLayoutFormAlignment_Type()
{
return QStyle::SH_FormLayoutFormAlignment;
}
int QStyle_SH_FormLayoutLabelAlignment_Type()
{
return QStyle::SH_FormLayoutLabelAlignment;
}
int QStyle_SH_ItemView_DrawDelegateFrame_Type()
{
return QStyle::SH_ItemView_DrawDelegateFrame;
}
int QStyle_SH_TabBar_CloseButtonPosition_Type()
{
return QStyle::SH_TabBar_CloseButtonPosition;
}
int QStyle_SH_DockWidget_ButtonsHaveFrame_Type()
{
return QStyle::SH_DockWidget_ButtonsHaveFrame;
}
int QStyle_SH_ToolButtonStyle_Type()
{
return QStyle::SH_ToolButtonStyle;
}
int QStyle_SH_RequestSoftwareInputPanel_Type()
{
return QStyle::SH_RequestSoftwareInputPanel;
}
int QStyle_SH_ScrollBar_Transient_Type()
{
return QStyle::SH_ScrollBar_Transient;
}
int QStyle_SH_Menu_SupportsSections_Type()
{
return QStyle::SH_Menu_SupportsSections;
}
int QStyle_SH_ToolTip_WakeUpDelay_Type()
{
return QStyle::SH_ToolTip_WakeUpDelay;
}
int QStyle_SH_ToolTip_FallAsleepDelay_Type()
{
return QStyle::SH_ToolTip_FallAsleepDelay;
}
int QStyle_SH_Widget_Animate_Type()
{
return QStyle::SH_Widget_Animate;
}
int QStyle_SH_Splitter_OpaqueResize_Type()
{
return QStyle::SH_Splitter_OpaqueResize;
}
int QStyle_SH_ComboBox_UseNativePopup_Type()
{
return QStyle::SH_ComboBox_UseNativePopup;
}
int QStyle_SH_LineEdit_PasswordMaskDelay_Type()
{
return QStyle::SH_LineEdit_PasswordMaskDelay;
}
int QStyle_SH_TabBar_ChangeCurrentDelay_Type()
{
return QStyle::SH_TabBar_ChangeCurrentDelay;
}
int QStyle_SH_Menu_SubMenuUniDirection_Type()
{
return QStyle::SH_Menu_SubMenuUniDirection;
}
int QStyle_SH_Menu_SubMenuUniDirectionFailCount_Type()
{
return QStyle::SH_Menu_SubMenuUniDirectionFailCount;
}
int QStyle_SH_Menu_SubMenuSloppySelectOtherActions_Type()
{
return QStyle::SH_Menu_SubMenuSloppySelectOtherActions;
}
int QStyle_SH_Menu_SubMenuSloppyCloseTimeout_Type()
{
return QStyle::SH_Menu_SubMenuSloppyCloseTimeout;
}
int QStyle_SH_Menu_SubMenuResetWhenReenteringParent_Type()
{
return QStyle::SH_Menu_SubMenuResetWhenReenteringParent;
}
int QStyle_SH_Menu_SubMenuDontStartSloppyOnLeave_Type()
{
return QStyle::SH_Menu_SubMenuDontStartSloppyOnLeave;
}
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;
}
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), this->objectName().toUtf8().data(), painter, new QRect(static_cast<QRect>(rectangle).x(), static_cast<QRect>(rectangle).y(), static_cast<QRect>(rectangle).width(), static_cast<QRect>(rectangle).height()), alignment, new 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), this->objectName().toUtf8().data(), painter, new QRect(static_cast<QRect>(rectangle).x(), static_cast<QRect>(rectangle).y(), static_cast<QRect>(rectangle).width(), static_cast<QRect>(rectangle).height()), alignment, new QPalette(palette), enabled, text.toUtf8().data(), textRole); };
QRect itemPixmapRect(const QRect & rectangle, int alignment, const QPixmap & pixmap) const { return *static_cast<QRect*>(callbackQStyle_ItemPixmapRect(const_cast<MyQStyle*>(this), this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rectangle).x(), static_cast<QRect>(rectangle).y(), static_cast<QRect>(rectangle).width(), static_cast<QRect>(rectangle).height()), alignment, new 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), this->objectName().toUtf8().data(), new QFontMetrics(metrics), new QRect(static_cast<QRect>(rectangle).x(), static_cast<QRect>(rectangle).y(), static_cast<QRect>(rectangle).width(), static_cast<QRect>(rectangle).height()), alignment, enabled, text.toUtf8().data())); };
void polish(QApplication * application) { callbackQStyle_Polish2(this, this->objectName().toUtf8().data(), application); };
void polish(QPalette & palette) { callbackQStyle_Polish3(this, this->objectName().toUtf8().data(), new QPalette(palette)); };
void unpolish(QApplication * application) { callbackQStyle_Unpolish2(this, this->objectName().toUtf8().data(), application); };
void drawComplexControl(QStyle::ComplexControl control, const QStyleOptionComplex * option, QPainter * painter, const QWidget * widget) const { callbackQStyle_DrawComplexControl(const_cast<MyQStyle*>(this), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), iconMode, new 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), this->objectName().toUtf8().data(), control, const_cast<QStyleOptionComplex*>(option), new QPoint(static_cast<QPoint>(position).x(), static_cast<QPoint>(position).y()), 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), metric, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget)); };
void polish(QWidget * widget) { callbackQStyle_Polish(this, this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), ty, const_cast<QStyleOption*>(option), new QSize(static_cast<QSize>(contentsSize).width(), static_cast<QSize>(contentsSize).height()), 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), this->objectName().toUtf8().data(), standardIcon, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
QPalette standardPalette() const { return *static_cast<QPalette*>(callbackQStyle_StandardPalette(const_cast<MyQStyle*>(this), this->objectName().toUtf8().data())); };
int styleHint(QStyle::StyleHint hint, const QStyleOption * option, const QWidget * widget, QStyleHintReturn * returnData) const { return callbackQStyle_StyleHint(const_cast<MyQStyle*>(this), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), 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), this->objectName().toUtf8().data(), element, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
void unpolish(QWidget * widget) { callbackQStyle_Unpolish(this, this->objectName().toUtf8().data(), widget); };
QPixmap standardPixmap(QStyle::StandardPixmap standardIcon, const QStyleOption * option, const QWidget * widget) const { return *static_cast<QPixmap*>(callbackQStyle_StandardPixmap(const_cast<MyQStyle*>(this), this->objectName().toUtf8().data(), standardIcon, const_cast<QStyleOption*>(option), const_cast<QWidget*>(widget))); };
void timerEvent(QTimerEvent * event) { callbackQStyle_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQStyle_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQStyle_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQStyle_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQStyle_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQStyle_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQStyle_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQStyle_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStyle_MetaObject(const_cast<MyQStyle*>(this), this->objectName().toUtf8().data())); };
};
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, int enabled, char* text, int 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, int enabled, char* text, int 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 new QRect(static_cast<QRect>(static_cast<QStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).x(), static_cast<QRect>(static_cast<QStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).y(), static_cast<QRect>(static_cast<QStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).width(), static_cast<QRect>(static_cast<QStyle*>(ptr)->itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).height());
}
void* QStyle_ItemPixmapRectDefault(void* ptr, void* rectangle, int alignment, void* pixmap)
{
return new QRect(static_cast<QRect>(static_cast<QStyle*>(ptr)->QStyle::itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).x(), static_cast<QRect>(static_cast<QStyle*>(ptr)->QStyle::itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).y(), static_cast<QRect>(static_cast<QStyle*>(ptr)->QStyle::itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).width(), static_cast<QRect>(static_cast<QStyle*>(ptr)->QStyle::itemPixmapRect(*static_cast<QRect*>(rectangle), alignment, *static_cast<QPixmap*>(pixmap))).height());
}
void* QStyle_ItemTextRect(void* ptr, void* metrics, void* rectangle, int alignment, int enabled, char* text)
{
return new QRect(static_cast<QRect>(static_cast<QStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).x(), static_cast<QRect>(static_cast<QStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).y(), static_cast<QRect>(static_cast<QStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).width(), static_cast<QRect>(static_cast<QStyle*>(ptr)->itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).height());
}
void* QStyle_ItemTextRectDefault(void* ptr, void* metrics, void* rectangle, int alignment, int enabled, char* text)
{
return new QRect(static_cast<QRect>(static_cast<QStyle*>(ptr)->QStyle::itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).x(), static_cast<QRect>(static_cast<QStyle*>(ptr)->QStyle::itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).y(), static_cast<QRect>(static_cast<QStyle*>(ptr)->QStyle::itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).width(), static_cast<QRect>(static_cast<QStyle*>(ptr)->QStyle::itemTextRect(*static_cast<QFontMetrics*>(metrics), *static_cast<QRect*>(rectangle), alignment, enabled != 0, QString(text))).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, int 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(int direction, void* boundingRectangle, void* logicalPosition)
{
return new QPoint(static_cast<QPoint>(QStyle::visualPos(static_cast<Qt::LayoutDirection>(direction), *static_cast<QRect*>(boundingRectangle), *static_cast<QPoint*>(logicalPosition))).x(), static_cast<QPoint>(QStyle::visualPos(static_cast<Qt::LayoutDirection>(direction), *static_cast<QRect*>(boundingRectangle), *static_cast<QPoint*>(logicalPosition))).y());
}
void* QStyle_QStyle_VisualRect(int direction, void* boundingRectangle, void* logicalRectangle)
{
return new QRect(static_cast<QRect>(QStyle::visualRect(static_cast<Qt::LayoutDirection>(direction), *static_cast<QRect*>(boundingRectangle), *static_cast<QRect*>(logicalRectangle))).x(), static_cast<QRect>(QStyle::visualRect(static_cast<Qt::LayoutDirection>(direction), *static_cast<QRect*>(boundingRectangle), *static_cast<QRect*>(logicalRectangle))).y(), static_cast<QRect>(QStyle::visualRect(static_cast<Qt::LayoutDirection>(direction), *static_cast<QRect*>(boundingRectangle), *static_cast<QRect*>(logicalRectangle))).width(), static_cast<QRect>(QStyle::visualRect(static_cast<Qt::LayoutDirection>(direction), *static_cast<QRect*>(boundingRectangle), *static_cast<QRect*>(logicalRectangle))).height());
}
void* QStyle_NewQStyle()
{
return new MyQStyle();
}
void* QStyle_QStyle_AlignedRect(int direction, int alignment, void* size, void* rectangle)
{
return new QRect(static_cast<QRect>(QStyle::alignedRect(static_cast<Qt::LayoutDirection>(direction), static_cast<Qt::AlignmentFlag>(alignment), *static_cast<QSize*>(size), *static_cast<QRect*>(rectangle))).x(), static_cast<QRect>(QStyle::alignedRect(static_cast<Qt::LayoutDirection>(direction), static_cast<Qt::AlignmentFlag>(alignment), *static_cast<QSize*>(size), *static_cast<QRect*>(rectangle))).y(), static_cast<QRect>(QStyle::alignedRect(static_cast<Qt::LayoutDirection>(direction), static_cast<Qt::AlignmentFlag>(alignment), *static_cast<QSize*>(size), *static_cast<QRect*>(rectangle))).width(), static_cast<QRect>(QStyle::alignedRect(static_cast<Qt::LayoutDirection>(direction), static_cast<Qt::AlignmentFlag>(alignment), *static_cast<QSize*>(size), *static_cast<QRect*>(rectangle))).height());
}
int QStyle_CombinedLayoutSpacing(void* ptr, int controls1, int controls2, int 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, int 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, int 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, int 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, int 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)));
}
int QStyle_HitTestComplexControl(void* ptr, int 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, int control1, int control2, int 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, int 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, int ty, void* option, void* contentsSize, void* widget)
{
return new QSize(static_cast<QSize>(static_cast<QStyle*>(ptr)->sizeFromContents(static_cast<QStyle::ContentsType>(ty), static_cast<QStyleOption*>(option), *static_cast<QSize*>(contentsSize), static_cast<QWidget*>(widget))).width(), static_cast<QSize>(static_cast<QStyle*>(ptr)->sizeFromContents(static_cast<QStyle::ContentsType>(ty), static_cast<QStyleOption*>(option), *static_cast<QSize*>(contentsSize), static_cast<QWidget*>(widget))).height());
}
int QStyle_QStyle_SliderPositionFromValue(int min, int max, int logicalValue, int span, int upsideDown)
{
return QStyle::sliderPositionFromValue(min, max, logicalValue, span, upsideDown != 0);
}
void* QStyle_StandardIcon(void* ptr, int 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, int 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, int control, void* option, int subControl, void* widget)
{
return new QRect(static_cast<QRect>(static_cast<QStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(control), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(subControl), static_cast<QWidget*>(widget))).x(), static_cast<QRect>(static_cast<QStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(control), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(subControl), static_cast<QWidget*>(widget))).y(), static_cast<QRect>(static_cast<QStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(control), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(subControl), static_cast<QWidget*>(widget))).width(), static_cast<QRect>(static_cast<QStyle*>(ptr)->subControlRect(static_cast<QStyle::ComplexControl>(control), static_cast<QStyleOptionComplex*>(option), static_cast<QStyle::SubControl>(subControl), static_cast<QWidget*>(widget))).height());
}
void* QStyle_SubElementRect(void* ptr, int element, void* option, void* widget)
{
return new QRect(static_cast<QRect>(static_cast<QStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(element), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget))).x(), static_cast<QRect>(static_cast<QStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(element), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget))).y(), static_cast<QRect>(static_cast<QStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(element), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget))).width(), static_cast<QRect>(static_cast<QStyle*>(ptr)->subElementRect(static_cast<QStyle::SubElement>(element), static_cast<QStyleOption*>(option), static_cast<QWidget*>(widget))).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));
}
int QStyle_QStyle_VisualAlignment(int direction, int 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_StandardPixmap(void* ptr, int 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));
}
int QStyle_Event(void* ptr, void* e)
{
return static_cast<QStyle*>(ptr)->event(static_cast<QEvent*>(e));
}
int QStyle_EventDefault(void* ptr, void* e)
{
return static_cast<QStyle*>(ptr)->QStyle::event(static_cast<QEvent*>(e));
}
int QStyle_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QStyle*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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 QStyleFactory::keys().join("|").toUtf8().data();
}
int QStyleHintReturn_SH_Mask_Type()
{
return QStyleHintReturn::SH_Mask;
}
int QStyleHintReturn_SH_Variant_Type()
{
return QStyleHintReturn::SH_Variant;
}
void* QStyleHintReturn_NewQStyleHintReturn(int version, int ty)
{
return new QStyleHintReturn(version, ty);
}
void* QStyleHintReturnMask_NewQStyleHintReturnMask()
{
return new QStyleHintReturnMask();
}
void QStyleHintReturnMask_DestroyQStyleHintReturnMask(void* ptr)
{
static_cast<QStyleHintReturnMask*>(ptr)->~QStyleHintReturnMask();
}
void* QStyleHintReturnVariant_NewQStyleHintReturnVariant()
{
return new QStyleHintReturnVariant();
}
void QStyleHintReturnVariant_DestroyQStyleHintReturnVariant(void* ptr)
{
static_cast<QStyleHintReturnVariant*>(ptr)->~QStyleHintReturnVariant();
}
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();
}
void* QStyleOptionButton_NewQStyleOptionButton()
{
return new QStyleOptionButton();
}
void* QStyleOptionButton_NewQStyleOptionButton2(void* other)
{
return new QStyleOptionButton(*static_cast<QStyleOptionButton*>(other));
}
void* QStyleOptionComboBox_NewQStyleOptionComboBox()
{
return new QStyleOptionComboBox();
}
void* QStyleOptionComboBox_NewQStyleOptionComboBox2(void* other)
{
return new QStyleOptionComboBox(*static_cast<QStyleOptionComboBox*>(other));
}
void* QStyleOptionComplex_NewQStyleOptionComplex2(void* other)
{
return new QStyleOptionComplex(*static_cast<QStyleOptionComplex*>(other));
}
void* QStyleOptionComplex_NewQStyleOptionComplex(int version, int ty)
{
return new QStyleOptionComplex(version, ty);
}
void* QStyleOptionDockWidget_NewQStyleOptionDockWidget()
{
return new QStyleOptionDockWidget();
}
void* QStyleOptionDockWidget_NewQStyleOptionDockWidget2(void* other)
{
return new QStyleOptionDockWidget(*static_cast<QStyleOptionDockWidget*>(other));
}
void* QStyleOptionFocusRect_NewQStyleOptionFocusRect()
{
return new QStyleOptionFocusRect();
}
void* QStyleOptionFocusRect_NewQStyleOptionFocusRect2(void* other)
{
return new QStyleOptionFocusRect(*static_cast<QStyleOptionFocusRect*>(other));
}
void* QStyleOptionFrame_NewQStyleOptionFrame()
{
return new QStyleOptionFrame();
}
void* QStyleOptionFrame_NewQStyleOptionFrame2(void* other)
{
return new QStyleOptionFrame(*static_cast<QStyleOptionFrame*>(other));
}
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 static_cast<double>(QStyleOptionGraphicsItem::levelOfDetailFromTransform(*static_cast<QTransform*>(worldTransform)));
}
void* QStyleOptionGroupBox_NewQStyleOptionGroupBox()
{
return new QStyleOptionGroupBox();
}
void* QStyleOptionGroupBox_NewQStyleOptionGroupBox2(void* other)
{
return new QStyleOptionGroupBox(*static_cast<QStyleOptionGroupBox*>(other));
}
void* QStyleOptionHeader_NewQStyleOptionHeader()
{
return new QStyleOptionHeader();
}
void* QStyleOptionHeader_NewQStyleOptionHeader2(void* other)
{
return new QStyleOptionHeader(*static_cast<QStyleOptionHeader*>(other));
}
void* QStyleOptionMenuItem_NewQStyleOptionMenuItem()
{
return new QStyleOptionMenuItem();
}
void* QStyleOptionMenuItem_NewQStyleOptionMenuItem2(void* other)
{
return new QStyleOptionMenuItem(*static_cast<QStyleOptionMenuItem*>(other));
}
void* QStyleOptionProgressBar_NewQStyleOptionProgressBar()
{
return new QStyleOptionProgressBar();
}
void* QStyleOptionProgressBar_NewQStyleOptionProgressBar2(void* other)
{
return new QStyleOptionProgressBar(*static_cast<QStyleOptionProgressBar*>(other));
}
void* QStyleOptionRubberBand_NewQStyleOptionRubberBand()
{
return new QStyleOptionRubberBand();
}
void* QStyleOptionRubberBand_NewQStyleOptionRubberBand2(void* other)
{
return new QStyleOptionRubberBand(*static_cast<QStyleOptionRubberBand*>(other));
}
void* QStyleOptionSizeGrip_NewQStyleOptionSizeGrip()
{
return new QStyleOptionSizeGrip();
}
void* QStyleOptionSizeGrip_NewQStyleOptionSizeGrip2(void* other)
{
return new QStyleOptionSizeGrip(*static_cast<QStyleOptionSizeGrip*>(other));
}
void* QStyleOptionSlider_NewQStyleOptionSlider()
{
return new QStyleOptionSlider();
}
void* QStyleOptionSlider_NewQStyleOptionSlider2(void* other)
{
return new QStyleOptionSlider(*static_cast<QStyleOptionSlider*>(other));
}
void* QStyleOptionSpinBox_NewQStyleOptionSpinBox()
{
return new QStyleOptionSpinBox();
}
void* QStyleOptionSpinBox_NewQStyleOptionSpinBox2(void* other)
{
return new QStyleOptionSpinBox(*static_cast<QStyleOptionSpinBox*>(other));
}
void* QStyleOptionTab_NewQStyleOptionTab()
{
return new QStyleOptionTab();
}
void* QStyleOptionTab_NewQStyleOptionTab2(void* other)
{
return new QStyleOptionTab(*static_cast<QStyleOptionTab*>(other));
}
void* QStyleOptionTabBarBase_NewQStyleOptionTabBarBase()
{
return new QStyleOptionTabBarBase();
}
void* QStyleOptionTabBarBase_NewQStyleOptionTabBarBase2(void* other)
{
return new QStyleOptionTabBarBase(*static_cast<QStyleOptionTabBarBase*>(other));
}
void* QStyleOptionTabWidgetFrame_NewQStyleOptionTabWidgetFrame()
{
return new QStyleOptionTabWidgetFrame();
}
void* QStyleOptionTabWidgetFrame_NewQStyleOptionTabWidgetFrame2(void* other)
{
return new QStyleOptionTabWidgetFrame(*static_cast<QStyleOptionTabWidgetFrame*>(other));
}
void* QStyleOptionTitleBar_NewQStyleOptionTitleBar()
{
return new QStyleOptionTitleBar();
}
void* QStyleOptionTitleBar_NewQStyleOptionTitleBar2(void* other)
{
return new QStyleOptionTitleBar(*static_cast<QStyleOptionTitleBar*>(other));
}
void* QStyleOptionToolBar_NewQStyleOptionToolBar()
{
return new QStyleOptionToolBar();
}
void* QStyleOptionToolBar_NewQStyleOptionToolBar2(void* other)
{
return new QStyleOptionToolBar(*static_cast<QStyleOptionToolBar*>(other));
}
void* QStyleOptionToolBox_NewQStyleOptionToolBox()
{
return new QStyleOptionToolBox();
}
void* QStyleOptionToolBox_NewQStyleOptionToolBox2(void* other)
{
return new QStyleOptionToolBox(*static_cast<QStyleOptionToolBox*>(other));
}
void* QStyleOptionToolButton_NewQStyleOptionToolButton()
{
return new QStyleOptionToolButton();
}
void* QStyleOptionToolButton_NewQStyleOptionToolButton2(void* other)
{
return new QStyleOptionToolButton(*static_cast<QStyleOptionToolButton*>(other));
}
void* QStyleOptionViewItem_NewQStyleOptionViewItem()
{
return new QStyleOptionViewItem();
}
void* QStyleOptionViewItem_NewQStyleOptionViewItem2(void* other)
{
return new QStyleOptionViewItem(*static_cast<QStyleOptionViewItem*>(other));
}
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));
}
int QStylePainter_Begin2(void* ptr, void* pd, void* widget)
{
return static_cast<QStylePainter*>(ptr)->begin(static_cast<QPaintDevice*>(pd), static_cast<QWidget*>(widget));
}
int QStylePainter_Begin(void* ptr, void* widget)
{
return static_cast<QStylePainter*>(ptr)->begin(static_cast<QWidget*>(widget));
}
void QStylePainter_DrawComplexControl(void* ptr, int cc, void* option)
{
static_cast<QStylePainter*>(ptr)->drawComplexControl(static_cast<QStyle::ComplexControl>(cc), *static_cast<QStyleOptionComplex*>(option));
}
void QStylePainter_DrawControl(void* ptr, int 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, int enabled, char* text, int 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, int 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, this->objectName().toUtf8().data(), key.toUtf8().data())); };
void timerEvent(QTimerEvent * event) { callbackQStylePlugin_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQStylePlugin_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQStylePlugin_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQStylePlugin_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQStylePlugin_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQStylePlugin_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQStylePlugin_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQStylePlugin_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStylePlugin_MetaObject(const_cast<MyQStylePlugin*>(this), this->objectName().toUtf8().data())); };
};
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));
}
int QStylePlugin_Event(void* ptr, void* e)
{
return static_cast<QStylePlugin*>(ptr)->event(static_cast<QEvent*>(e));
}
int QStylePlugin_EventDefault(void* ptr, void* e)
{
return static_cast<QStylePlugin*>(ptr)->QStylePlugin::event(static_cast<QEvent*>(e));
}
int QStylePlugin_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QStylePlugin*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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), this->objectName().toUtf8().data(), parent, new QStyleOptionViewItem(option), new QModelIndex(index))); };
QString displayText(const QVariant & value, const QLocale & locale) const { return QString(callbackQStyledItemDelegate_DisplayText(const_cast<MyQStyledItemDelegate*>(this), this->objectName().toUtf8().data(), new QVariant(value), new QLocale(locale))); };
bool editorEvent(QEvent * event, QAbstractItemModel * model, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQStyledItemDelegate_EditorEvent(this, this->objectName().toUtf8().data(), event, model, new QStyleOptionViewItem(option), new QModelIndex(index)) != 0; };
void initStyleOption(QStyleOptionViewItem * option, const QModelIndex & index) const { callbackQStyledItemDelegate_InitStyleOption(const_cast<MyQStyledItemDelegate*>(this), this->objectName().toUtf8().data(), option, new QModelIndex(index)); };
void paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQStyledItemDelegate_Paint(const_cast<MyQStyledItemDelegate*>(this), this->objectName().toUtf8().data(), painter, new QStyleOptionViewItem(option), new QModelIndex(index)); };
void setEditorData(QWidget * editor, const QModelIndex & index) const { callbackQStyledItemDelegate_SetEditorData(const_cast<MyQStyledItemDelegate*>(this), this->objectName().toUtf8().data(), editor, new QModelIndex(index)); };
void setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex & index) const { callbackQStyledItemDelegate_SetModelData(const_cast<MyQStyledItemDelegate*>(this), this->objectName().toUtf8().data(), editor, model, new QModelIndex(index)); };
QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex & index) const { return *static_cast<QSize*>(callbackQStyledItemDelegate_SizeHint(const_cast<MyQStyledItemDelegate*>(this), this->objectName().toUtf8().data(), new QStyleOptionViewItem(option), new QModelIndex(index))); };
void updateEditorGeometry(QWidget * editor, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQStyledItemDelegate_UpdateEditorGeometry(const_cast<MyQStyledItemDelegate*>(this), this->objectName().toUtf8().data(), editor, new QStyleOptionViewItem(option), new QModelIndex(index)); };
void destroyEditor(QWidget * editor, const QModelIndex & index) const { callbackQStyledItemDelegate_DestroyEditor(const_cast<MyQStyledItemDelegate*>(this), this->objectName().toUtf8().data(), editor, new QModelIndex(index)); };
bool helpEvent(QHelpEvent * event, QAbstractItemView * view, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQStyledItemDelegate_HelpEvent(this, this->objectName().toUtf8().data(), event, view, new QStyleOptionViewItem(option), new QModelIndex(index)) != 0; };
void timerEvent(QTimerEvent * event) { callbackQStyledItemDelegate_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQStyledItemDelegate_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQStyledItemDelegate_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQStyledItemDelegate_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQStyledItemDelegate_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQStyledItemDelegate_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQStyledItemDelegate_Event(this, this->objectName().toUtf8().data(), e) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStyledItemDelegate_MetaObject(const_cast<MyQStyledItemDelegate*>(this), this->objectName().toUtf8().data())); };
};
int 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 static_cast<QStyledItemDelegate*>(ptr)->displayText(*static_cast<QVariant*>(value), *static_cast<QLocale*>(locale)).toUtf8().data();
}
char* QStyledItemDelegate_DisplayTextDefault(void* ptr, void* value, void* locale)
{
return static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::displayText(*static_cast<QVariant*>(value), *static_cast<QLocale*>(locale)).toUtf8().data();
}
int 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));
}
int 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 new QSize(static_cast<QSize>(static_cast<QStyledItemDelegate*>(ptr)->sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index))).width(), static_cast<QSize>(static_cast<QStyledItemDelegate*>(ptr)->sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index))).height());
}
void* QStyledItemDelegate_SizeHintDefault(void* ptr, void* option, void* index)
{
return new QSize(static_cast<QSize>(static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index))).width(), static_cast<QSize>(static_cast<QStyledItemDelegate*>(ptr)->QStyledItemDelegate::sizeHint(*static_cast<QStyleOptionViewItem*>(option), *static_cast<QModelIndex*>(index))).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));
}
int 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));
}
int 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));
}
int QStyledItemDelegate_Event(void* ptr, void* e)
{
return static_cast<QStyledItemDelegate*>(ptr)->event(static_cast<QEvent*>(e));
}
int 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());
}
int QSwipeGesture_HorizontalDirection(void* ptr)
{
return static_cast<QSwipeGesture*>(ptr)->horizontalDirection();
}
void QSwipeGesture_SetSwipeAngle(void* ptr, double value)
{
static_cast<QSwipeGesture*>(ptr)->setSwipeAngle(static_cast<double>(value));
}
double QSwipeGesture_SwipeAngle(void* ptr)
{
return static_cast<double>(static_cast<QSwipeGesture*>(ptr)->swipeAngle());
}
int 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));
}
int QSwipeGesture_Event(void* ptr, void* e)
{
return static_cast<QSwipeGesture*>(ptr)->event(static_cast<QEvent*>(e));
}
int QSwipeGesture_EventDefault(void* ptr, void* e)
{
return static_cast<QSwipeGesture*>(ptr)->QSwipeGesture::event(static_cast<QEvent*>(e));
}
int QSwipeGesture_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QSwipeGesture*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), visible); };
void showMessage(const QString & title, const QString & message, QSystemTrayIcon::MessageIcon icon, int millisecondsTimeoutHint) { callbackQSystemTrayIcon_ShowMessage(this, this->objectName().toUtf8().data(), title.toUtf8().data(), message.toUtf8().data(), icon, millisecondsTimeoutHint); };
void Signal_Activated(QSystemTrayIcon::ActivationReason reason) { callbackQSystemTrayIcon_Activated(this, this->objectName().toUtf8().data(), reason); };
void hide() { callbackQSystemTrayIcon_Hide(this, this->objectName().toUtf8().data()); };
void Signal_MessageClicked() { callbackQSystemTrayIcon_MessageClicked(this, this->objectName().toUtf8().data()); };
void show() { callbackQSystemTrayIcon_Show(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQSystemTrayIcon_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQSystemTrayIcon_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQSystemTrayIcon_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQSystemTrayIcon_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQSystemTrayIcon_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQSystemTrayIcon_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQSystemTrayIcon_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSystemTrayIcon_MetaObject(const_cast<MyQSystemTrayIcon*>(this), this->objectName().toUtf8().data())); };
};
void* QSystemTrayIcon_Icon(void* ptr)
{
return new QIcon(static_cast<QSystemTrayIcon*>(ptr)->icon());
}
int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QSystemTrayIcon*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QSystemTrayIcon_ShowMessage(void* ptr, char* title, char* message, int 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 static_cast<QSystemTrayIcon*>(ptr)->toolTip().toUtf8().data();
}
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, int reason)
{
static_cast<QSystemTrayIcon*>(ptr)->activated(static_cast<QSystemTrayIcon::ActivationReason>(reason));
}
void* QSystemTrayIcon_ContextMenu(void* ptr)
{
return static_cast<QSystemTrayIcon*>(ptr)->contextMenu();
}
int QSystemTrayIcon_Event(void* ptr, void* e)
{
return static_cast<QSystemTrayIcon*>(ptr)->event(static_cast<QEvent*>(e));
}
void* QSystemTrayIcon_Geometry(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QSystemTrayIcon*>(ptr)->geometry()).x(), static_cast<QRect>(static_cast<QSystemTrayIcon*>(ptr)->geometry()).y(), static_cast<QRect>(static_cast<QSystemTrayIcon*>(ptr)->geometry()).width(), static_cast<QRect>(static_cast<QSystemTrayIcon*>(ptr)->geometry()).height());
}
void QSystemTrayIcon_Hide(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QSystemTrayIcon*>(ptr), "hide");
}
int 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");
}
int 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));
}
int QSystemTrayIcon_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QSystemTrayIcon*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), index); };
void changeEvent(QEvent * event) { callbackQTabBar_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_CurrentChanged(int index) { callbackQTabBar_CurrentChanged(this, this->objectName().toUtf8().data(), index); };
void hideEvent(QHideEvent * vqh) { callbackQTabBar_HideEvent(this, this->objectName().toUtf8().data(), vqh); };
void keyPressEvent(QKeyEvent * event) { callbackQTabBar_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTabBar_MinimumSizeHint(const_cast<MyQTabBar*>(this), this->objectName().toUtf8().data())); };
QSize minimumTabSizeHint(int index) const { return *static_cast<QSize*>(callbackQTabBar_MinimumTabSizeHint(const_cast<MyQTabBar*>(this), this->objectName().toUtf8().data(), index)); };
void mouseMoveEvent(QMouseEvent * event) { callbackQTabBar_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQTabBar_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQTabBar_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * vqp) { callbackQTabBar_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
void resizeEvent(QResizeEvent * vqr) { callbackQTabBar_ResizeEvent(this, this->objectName().toUtf8().data(), vqr); };
void showEvent(QShowEvent * vqs) { callbackQTabBar_ShowEvent(this, this->objectName().toUtf8().data(), vqs); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQTabBar_SizeHint(const_cast<MyQTabBar*>(this), this->objectName().toUtf8().data())); };
void Signal_TabBarClicked(int index) { callbackQTabBar_TabBarClicked(this, this->objectName().toUtf8().data(), index); };
void Signal_TabBarDoubleClicked(int index) { callbackQTabBar_TabBarDoubleClicked(this, this->objectName().toUtf8().data(), index); };
void Signal_TabCloseRequested(int index) { callbackQTabBar_TabCloseRequested(this, this->objectName().toUtf8().data(), index); };
void tabInserted(int index) { callbackQTabBar_TabInserted(this, this->objectName().toUtf8().data(), index); };
void tabLayoutChange() { callbackQTabBar_TabLayoutChange(this, this->objectName().toUtf8().data()); };
void Signal_TabMoved(int from, int to) { callbackQTabBar_TabMoved(this, this->objectName().toUtf8().data(), from, to); };
void tabRemoved(int index) { callbackQTabBar_TabRemoved(this, this->objectName().toUtf8().data(), index); };
QSize tabSizeHint(int index) const { return *static_cast<QSize*>(callbackQTabBar_TabSizeHint(const_cast<MyQTabBar*>(this), this->objectName().toUtf8().data(), index)); };
void wheelEvent(QWheelEvent * event) { callbackQTabBar_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void actionEvent(QActionEvent * event) { callbackQTabBar_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQTabBar_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQTabBar_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQTabBar_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQTabBar_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQTabBar_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQTabBar_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQTabBar_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQTabBar_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQTabBar_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQTabBar_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQTabBar_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQTabBar_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQTabBar_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQTabBar_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQTabBar_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQTabBar_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQTabBar_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQTabBar_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQTabBar_HasHeightForWidth(const_cast<MyQTabBar*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQTabBar_HeightForWidth(const_cast<MyQTabBar*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQTabBar_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQTabBar_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQTabBar_InputMethodQuery(const_cast<MyQTabBar*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQTabBar_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQTabBar_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQTabBar_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTabBar_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQTabBar_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQTabBar_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQTabBar_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQTabBar_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQTabBar_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQTabBar_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQTabBar_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQTabBar_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQTabBar_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQTabBar_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQTabBar_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQTabBar_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQTabBar_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQTabBar_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQTabBar_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQTabBar_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQTabBar_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTabBar_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTabBar_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTabBar_MetaObject(const_cast<MyQTabBar*>(this), this->objectName().toUtf8().data())); };
};
int QTabBar_AutoHide(void* ptr)
{
return static_cast<QTabBar*>(ptr)->autoHide();
}
int 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();
}
int QTabBar_DocumentMode(void* ptr)
{
return static_cast<QTabBar*>(ptr)->documentMode();
}
int QTabBar_DrawBase(void* ptr)
{
return static_cast<QTabBar*>(ptr)->drawBase();
}
int QTabBar_ElideMode(void* ptr)
{
return static_cast<QTabBar*>(ptr)->elideMode();
}
int QTabBar_Expanding(void* ptr)
{
return static_cast<QTabBar*>(ptr)->expanding();
}
void* QTabBar_IconSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTabBar*>(ptr)->iconSize()).width(), static_cast<QSize>(static_cast<QTabBar*>(ptr)->iconSize()).height());
}
int QTabBar_IsMovable(void* ptr)
{
return static_cast<QTabBar*>(ptr)->isMovable();
}
int QTabBar_SelectionBehaviorOnRemove(void* ptr)
{
return static_cast<QTabBar*>(ptr)->selectionBehaviorOnRemove();
}
void QTabBar_SetAutoHide(void* ptr, int hide)
{
static_cast<QTabBar*>(ptr)->setAutoHide(hide != 0);
}
void QTabBar_SetChangeCurrentOnDrag(void* ptr, int 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, int set)
{
static_cast<QTabBar*>(ptr)->setDocumentMode(set != 0);
}
void QTabBar_SetDrawBase(void* ptr, int drawTheBase)
{
static_cast<QTabBar*>(ptr)->setDrawBase(drawTheBase != 0);
}
void QTabBar_SetElideMode(void* ptr, int vqt)
{
static_cast<QTabBar*>(ptr)->setElideMode(static_cast<Qt::TextElideMode>(vqt));
}
void QTabBar_SetExpanding(void* ptr, int 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, int movable)
{
static_cast<QTabBar*>(ptr)->setMovable(movable != 0);
}
void QTabBar_SetSelectionBehaviorOnRemove(void* ptr, int behavior)
{
static_cast<QTabBar*>(ptr)->setSelectionBehaviorOnRemove(static_cast<QTabBar::SelectionBehavior>(behavior));
}
void QTabBar_SetShape(void* ptr, int shape)
{
static_cast<QTabBar*>(ptr)->setShape(static_cast<QTabBar::Shape>(shape));
}
void QTabBar_SetTabsClosable(void* ptr, int closable)
{
static_cast<QTabBar*>(ptr)->setTabsClosable(closable != 0);
}
void QTabBar_SetUsesScrollButtons(void* ptr, int useButtons)
{
static_cast<QTabBar*>(ptr)->setUsesScrollButtons(useButtons != 0);
}
int QTabBar_Shape(void* ptr)
{
return static_cast<QTabBar*>(ptr)->shape();
}
int QTabBar_TabsClosable(void* ptr)
{
return static_cast<QTabBar*>(ptr)->tabsClosable();
}
int 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);
}
int 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));
}
int 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 new QSize(static_cast<QSize>(static_cast<QTabBar*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTabBar*>(ptr)->minimumSizeHint()).height());
}
void* QTabBar_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTabBar*>(ptr)->QTabBar::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTabBar*>(ptr)->QTabBar::minimumSizeHint()).height());
}
void* QTabBar_MinimumTabSizeHint(void* ptr, int index)
{
return new QSize(static_cast<QSize>(static_cast<QTabBar*>(ptr)->minimumTabSizeHint(index)).width(), static_cast<QSize>(static_cast<QTabBar*>(ptr)->minimumTabSizeHint(index)).height());
}
void* QTabBar_MinimumTabSizeHintDefault(void* ptr, int index)
{
return new QSize(static_cast<QSize>(static_cast<QTabBar*>(ptr)->QTabBar::minimumTabSizeHint(index)).width(), static_cast<QSize>(static_cast<QTabBar*>(ptr)->QTabBar::minimumTabSizeHint(index)).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, int 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, int 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 new QSize(static_cast<QSize>(static_cast<QTabBar*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QTabBar*>(ptr)->sizeHint()).height());
}
void* QTabBar_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTabBar*>(ptr)->QTabBar::sizeHint()).width(), static_cast<QSize>(static_cast<QTabBar*>(ptr)->QTabBar::sizeHint()).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, int 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 new QRect(static_cast<QRect>(static_cast<QTabBar*>(ptr)->tabRect(index)).x(), static_cast<QRect>(static_cast<QTabBar*>(ptr)->tabRect(index)).y(), static_cast<QRect>(static_cast<QTabBar*>(ptr)->tabRect(index)).width(), static_cast<QRect>(static_cast<QTabBar*>(ptr)->tabRect(index)).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 new QSize(static_cast<QSize>(static_cast<QTabBar*>(ptr)->tabSizeHint(index)).width(), static_cast<QSize>(static_cast<QTabBar*>(ptr)->tabSizeHint(index)).height());
}
void* QTabBar_TabSizeHintDefault(void* ptr, int index)
{
return new QSize(static_cast<QSize>(static_cast<QTabBar*>(ptr)->QTabBar::tabSizeHint(index)).width(), static_cast<QSize>(static_cast<QTabBar*>(ptr)->QTabBar::tabSizeHint(index)).height());
}
char* QTabBar_TabText(void* ptr, int index)
{
return static_cast<QTabBar*>(ptr)->tabText(index).toUtf8().data();
}
void* QTabBar_TabTextColor(void* ptr, int index)
{
return new QColor(static_cast<QTabBar*>(ptr)->tabTextColor(index));
}
char* QTabBar_TabToolTip(void* ptr, int index)
{
return static_cast<QTabBar*>(ptr)->tabToolTip(index).toUtf8().data();
}
char* QTabBar_TabWhatsThis(void* ptr, int index)
{
return static_cast<QTabBar*>(ptr)->tabWhatsThis(index).toUtf8().data();
}
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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QTabBar_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QTabBar_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QTabBar*>(ptr)->QTabBar::setVisible(visible != 0);
}
void QTabBar_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QTabBar_SetWindowModifiedDefault(void* ptr, int 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));
}
int QTabBar_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QTabBar_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QTabBar*>(ptr)->focusNextPrevChild(next != 0);
}
int QTabBar_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QTabBar*>(ptr)->QTabBar::focusNextPrevChild(next != 0);
}
int QTabBar_HasHeightForWidth(void* ptr)
{
return static_cast<QTabBar*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QTabBar*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QTabBar_InputMethodQueryDefault(void* ptr, int 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));
}
int QTabBar_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTabBar*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QTabBar_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTabBar*>(ptr)->QTabBar::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QTabBar_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QTabBar*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QTabBar_SetHiddenDefault(void* ptr, int 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));
}
int QTabBar_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QTabBar*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), event); };
void setCurrentIndex(int index) { callbackQTabWidget_SetCurrentIndex(this, this->objectName().toUtf8().data(), index); };
void changeEvent(QEvent * ev) { callbackQTabWidget_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void Signal_CurrentChanged(int index) { callbackQTabWidget_CurrentChanged(this, this->objectName().toUtf8().data(), index); };
bool hasHeightForWidth() const { return callbackQTabWidget_HasHeightForWidth(const_cast<MyQTabWidget*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int width) const { return callbackQTabWidget_HeightForWidth(const_cast<MyQTabWidget*>(this), this->objectName().toUtf8().data(), width); };
void keyPressEvent(QKeyEvent * e) { callbackQTabWidget_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTabWidget_MinimumSizeHint(const_cast<MyQTabWidget*>(this), this->objectName().toUtf8().data())); };
void resizeEvent(QResizeEvent * e) { callbackQTabWidget_ResizeEvent(this, this->objectName().toUtf8().data(), e); };
void setCurrentWidget(QWidget * widget) { callbackQTabWidget_SetCurrentWidget(this, this->objectName().toUtf8().data(), widget); };
void showEvent(QShowEvent * vqs) { callbackQTabWidget_ShowEvent(this, this->objectName().toUtf8().data(), vqs); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQTabWidget_SizeHint(const_cast<MyQTabWidget*>(this), this->objectName().toUtf8().data())); };
void Signal_TabBarClicked(int index) { callbackQTabWidget_TabBarClicked(this, this->objectName().toUtf8().data(), index); };
void Signal_TabBarDoubleClicked(int index) { callbackQTabWidget_TabBarDoubleClicked(this, this->objectName().toUtf8().data(), index); };
void Signal_TabCloseRequested(int index) { callbackQTabWidget_TabCloseRequested(this, this->objectName().toUtf8().data(), index); };
void tabInserted(int index) { callbackQTabWidget_TabInserted(this, this->objectName().toUtf8().data(), index); };
void tabRemoved(int index) { callbackQTabWidget_TabRemoved(this, this->objectName().toUtf8().data(), index); };
void actionEvent(QActionEvent * event) { callbackQTabWidget_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQTabWidget_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQTabWidget_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQTabWidget_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQTabWidget_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQTabWidget_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQTabWidget_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQTabWidget_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQTabWidget_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQTabWidget_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQTabWidget_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQTabWidget_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQTabWidget_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQTabWidget_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQTabWidget_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQTabWidget_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQTabWidget_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQTabWidget_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQTabWidget_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQTabWidget_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void hide() { callbackQTabWidget_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQTabWidget_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQTabWidget_InputMethodQuery(const_cast<MyQTabWidget*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQTabWidget_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQTabWidget_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQTabWidget_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQTabWidget_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQTabWidget_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQTabWidget_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTabWidget_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQTabWidget_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQTabWidget_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQTabWidget_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQTabWidget_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQTabWidget_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQTabWidget_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQTabWidget_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQTabWidget_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQTabWidget_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQTabWidget_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQTabWidget_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQTabWidget_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQTabWidget_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQTabWidget_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQTabWidget_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQTabWidget_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQTabWidget_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQTabWidget_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQTabWidget_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTabWidget_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTabWidget_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTabWidget_MetaObject(const_cast<MyQTabWidget*>(this), this->objectName().toUtf8().data())); };
};
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();
}
int QTabWidget_DocumentMode(void* ptr)
{
return static_cast<QTabWidget*>(ptr)->documentMode();
}
int QTabWidget_ElideMode(void* ptr)
{
return static_cast<QTabWidget*>(ptr)->elideMode();
}
void* QTabWidget_IconSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTabWidget*>(ptr)->iconSize()).width(), static_cast<QSize>(static_cast<QTabWidget*>(ptr)->iconSize()).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));
}
int 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, int 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, int set)
{
static_cast<QTabWidget*>(ptr)->setDocumentMode(set != 0);
}
void QTabWidget_SetElideMode(void* ptr, int 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, int movable)
{
static_cast<QTabWidget*>(ptr)->setMovable(movable != 0);
}
void QTabWidget_SetTabBarAutoHide(void* ptr, int enabled)
{
static_cast<QTabWidget*>(ptr)->setTabBarAutoHide(enabled != 0);
}
void QTabWidget_SetTabPosition(void* ptr, int vta)
{
static_cast<QTabWidget*>(ptr)->setTabPosition(static_cast<QTabWidget::TabPosition>(vta));
}
void QTabWidget_SetTabShape(void* ptr, int s)
{
static_cast<QTabWidget*>(ptr)->setTabShape(static_cast<QTabWidget::TabShape>(s));
}
void QTabWidget_SetTabsClosable(void* ptr, int closeable)
{
static_cast<QTabWidget*>(ptr)->setTabsClosable(closeable != 0);
}
void QTabWidget_SetUsesScrollButtons(void* ptr, int useButtons)
{
static_cast<QTabWidget*>(ptr)->setUsesScrollButtons(useButtons != 0);
}
int QTabWidget_TabBarAutoHide(void* ptr)
{
return static_cast<QTabWidget*>(ptr)->tabBarAutoHide();
}
int QTabWidget_TabPosition(void* ptr)
{
return static_cast<QTabWidget*>(ptr)->tabPosition();
}
int QTabWidget_TabShape(void* ptr)
{
return static_cast<QTabWidget*>(ptr)->tabShape();
}
int QTabWidget_TabsClosable(void* ptr)
{
return static_cast<QTabWidget*>(ptr)->tabsClosable();
}
int 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, int 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();
}
int QTabWidget_Event(void* ptr, void* ev)
{
return static_cast<QTabWidget*>(ptr)->event(static_cast<QEvent*>(ev));
}
int QTabWidget_HasHeightForWidth(void* ptr)
{
return static_cast<QTabWidget*>(ptr)->hasHeightForWidth();
}
int 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));
}
int 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 new QSize(static_cast<QSize>(static_cast<QTabWidget*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTabWidget*>(ptr)->minimumSizeHint()).height());
}
void* QTabWidget_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTabWidget*>(ptr)->QTabWidget::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTabWidget*>(ptr)->QTabWidget::minimumSizeHint()).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, int 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 new QSize(static_cast<QSize>(static_cast<QTabWidget*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QTabWidget*>(ptr)->sizeHint()).height());
}
void* QTabWidget_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTabWidget*>(ptr)->QTabWidget::sizeHint()).width(), static_cast<QSize>(static_cast<QTabWidget*>(ptr)->QTabWidget::sizeHint()).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 static_cast<QTabWidget*>(ptr)->tabText(index).toUtf8().data();
}
char* QTabWidget_TabToolTip(void* ptr, int index)
{
return static_cast<QTabWidget*>(ptr)->tabToolTip(index).toUtf8().data();
}
char* QTabWidget_TabWhatsThis(void* ptr, int index)
{
return static_cast<QTabWidget*>(ptr)->tabWhatsThis(index).toUtf8().data();
}
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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QTabWidget_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QTabWidget_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QTabWidget*>(ptr)->QTabWidget::setVisible(visible != 0);
}
void QTabWidget_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QTabWidget_SetWindowModifiedDefault(void* ptr, int 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));
}
int QTabWidget_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QTabWidget_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QTabWidget*>(ptr)->focusNextPrevChild(next != 0);
}
int QTabWidget_FocusNextPrevChildDefault(void* ptr, int 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, int query)
{
return new QVariant(static_cast<QTabWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QTabWidget_InputMethodQueryDefault(void* ptr, int 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));
}
int QTabWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTabWidget*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QTabWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTabWidget*>(ptr)->QTabWidget::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QTabWidget_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QTabWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QTabWidget_SetHiddenDefault(void* ptr, int 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));
}
int QTabWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QTabWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), cursorAction, modifiers)); };
void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags flags) { callbackQTableView_SetSelection(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), flags); };
void setShowGrid(bool show) { callbackQTableView_SetShowGrid(this, this->objectName().toUtf8().data(), show); };
void columnCountChanged(int oldCount, int newCount) { callbackQTableView_ColumnCountChanged(this, this->objectName().toUtf8().data(), oldCount, newCount); };
void columnMoved(int column, int oldIndex, int newIndex) { callbackQTableView_ColumnMoved(this, this->objectName().toUtf8().data(), column, oldIndex, newIndex); };
void columnResized(int column, int oldWidth, int newWidth) { callbackQTableView_ColumnResized(this, this->objectName().toUtf8().data(), column, oldWidth, newWidth); };
void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQTableView_CurrentChanged(this, this->objectName().toUtf8().data(), new QModelIndex(current), new QModelIndex(previous)); };
void hideColumn(int column) { callbackQTableView_HideColumn(this, this->objectName().toUtf8().data(), column); };
void hideRow(int row) { callbackQTableView_HideRow(this, this->objectName().toUtf8().data(), row); };
int horizontalOffset() const { return callbackQTableView_HorizontalOffset(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data()); };
QModelIndex indexAt(const QPoint & pos) const { return *static_cast<QModelIndex*>(callbackQTableView_IndexAt(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(pos).x(), static_cast<QPoint>(pos).y()))); };
bool isIndexHidden(const QModelIndex & index) const { return callbackQTableView_IsIndexHidden(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index)) != 0; };
void paintEvent(QPaintEvent * event) { callbackQTableView_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void resizeColumnToContents(int column) { callbackQTableView_ResizeColumnToContents(this, this->objectName().toUtf8().data(), column); };
void resizeColumnsToContents() { callbackQTableView_ResizeColumnsToContents(this, this->objectName().toUtf8().data()); };
void resizeRowToContents(int row) { callbackQTableView_ResizeRowToContents(this, this->objectName().toUtf8().data(), row); };
void resizeRowsToContents() { callbackQTableView_ResizeRowsToContents(this, this->objectName().toUtf8().data()); };
void rowCountChanged(int oldCount, int newCount) { callbackQTableView_RowCountChanged(this, this->objectName().toUtf8().data(), oldCount, newCount); };
void rowMoved(int row, int oldIndex, int newIndex) { callbackQTableView_RowMoved(this, this->objectName().toUtf8().data(), row, oldIndex, newIndex); };
void rowResized(int row, int oldHeight, int newHeight) { callbackQTableView_RowResized(this, this->objectName().toUtf8().data(), row, oldHeight, newHeight); };
void selectColumn(int column) { callbackQTableView_SelectColumn(this, this->objectName().toUtf8().data(), column); };
void selectRow(int row) { callbackQTableView_SelectRow(this, this->objectName().toUtf8().data(), row); };
void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQTableView_SelectionChanged(this, this->objectName().toUtf8().data(), new QItemSelection(selected), new QItemSelection(deselected)); };
void setModel(QAbstractItemModel * model) { callbackQTableView_SetModel(this, this->objectName().toUtf8().data(), model); };
void setRootIndex(const QModelIndex & index) { callbackQTableView_SetRootIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQTableView_SetSelectionModel(this, this->objectName().toUtf8().data(), selectionModel); };
void showColumn(int column) { callbackQTableView_ShowColumn(this, this->objectName().toUtf8().data(), column); };
void showRow(int row) { callbackQTableView_ShowRow(this, this->objectName().toUtf8().data(), row); };
int sizeHintForColumn(int column) const { return callbackQTableView_SizeHintForColumn(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data(), column); };
int sizeHintForRow(int row) const { return callbackQTableView_SizeHintForRow(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data(), row); };
void updateGeometries() { callbackQTableView_UpdateGeometries(this, this->objectName().toUtf8().data()); };
int verticalOffset() const { return callbackQTableView_VerticalOffset(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data()); };
QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQTableView_ViewOptions(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data())); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQTableView_ViewportSizeHint(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data())); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQTableView_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
bool viewportEvent(QEvent * event) { return callbackQTableView_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
void clearSelection() { callbackQTableView_ClearSelection(this, this->objectName().toUtf8().data()); };
void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQTableView_CloseEditor(this, this->objectName().toUtf8().data(), editor, hint); };
void commitData(QWidget * editor) { callbackQTableView_CommitData(this, this->objectName().toUtf8().data(), editor); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQTableView_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQTableView_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQTableView_DropEvent(this, this->objectName().toUtf8().data(), event); };
void edit(const QModelIndex & index) { callbackQTableView_Edit(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQTableView_Edit2(this, this->objectName().toUtf8().data(), new QModelIndex(index), trigger, event) != 0; };
void editorDestroyed(QObject * editor) { callbackQTableView_EditorDestroyed(this, this->objectName().toUtf8().data(), editor); };
void focusInEvent(QFocusEvent * event) { callbackQTableView_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQTableView_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * event) { callbackQTableView_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQTableView_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQTableView_InputMethodQuery(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQTableView_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyboardSearch(const QString & search) { callbackQTableView_KeyboardSearch(this, this->objectName().toUtf8().data(), search.toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQTableView_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQTableView_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQTableView_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQTableView_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void reset() { callbackQTableView_Reset(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQTableView_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQTableView_RowsAboutToBeRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQTableView_RowsInserted(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQTableView_ScrollTo(this, this->objectName().toUtf8().data(), new QModelIndex(index), hint); };
void scrollToBottom() { callbackQTableView_ScrollToBottom(this, this->objectName().toUtf8().data()); };
void scrollToTop() { callbackQTableView_ScrollToTop(this, this->objectName().toUtf8().data()); };
void selectAll() { callbackQTableView_SelectAll(this, this->objectName().toUtf8().data()); };
QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQTableView_SelectionCommand(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index), const_cast<QEvent*>(event))); };
void setCurrentIndex(const QModelIndex & index) { callbackQTableView_SetCurrentIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void startDrag(Qt::DropActions supportedActions) { callbackQTableView_StartDrag(this, this->objectName().toUtf8().data(), supportedActions); };
void update(const QModelIndex & index) { callbackQTableView_Update(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQTableView_VisualRect(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index))); };
QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQTableView_VisualRegionForSelection(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data(), new QItemSelection(selection))); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQTableView_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTableView_MinimumSizeHint(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data())); };
void scrollContentsBy(int dx, int dy) { callbackQTableView_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void setupViewport(QWidget * viewport) { callbackQTableView_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQTableView_SizeHint(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data())); };
void wheelEvent(QWheelEvent * e) { callbackQTableView_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void changeEvent(QEvent * ev) { callbackQTableView_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQTableView_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQTableView_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQTableView_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQTableView_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQTableView_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQTableView_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQTableView_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQTableView_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQTableView_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQTableView_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQTableView_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQTableView_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQTableView_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQTableView_HasHeightForWidth(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQTableView_HeightForWidth(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQTableView_Hide(this, this->objectName().toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * event) { callbackQTableView_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQTableView_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTableView_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQTableView_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQTableView_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQTableView_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQTableView_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQTableView_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQTableView_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQTableView_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQTableView_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQTableView_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQTableView_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQTableView_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void updateMicroFocus() { callbackQTableView_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQTableView_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQTableView_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQTableView_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQTableView_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTableView_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTableView_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTableView_MetaObject(const_cast<MyQTableView*>(this), this->objectName().toUtf8().data())); };
};
int QTableView_GridStyle(void* ptr)
{
return static_cast<QTableView*>(ptr)->gridStyle();
}
int QTableView_IsCornerButtonEnabled(void* ptr)
{
return static_cast<QTableView*>(ptr)->isCornerButtonEnabled();
}
int QTableView_IsSortingEnabled(void* ptr)
{
return static_cast<QTableView*>(ptr)->isSortingEnabled();
}
void* QTableView_MoveCursor(void* ptr, int cursorAction, int modifiers)
{
return new QModelIndex(static_cast<QTableView*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}
void* QTableView_MoveCursorDefault(void* ptr, int cursorAction, int 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, int enable)
{
static_cast<QTableView*>(ptr)->setCornerButtonEnabled(enable != 0);
}
void QTableView_SetGridStyle(void* ptr, int style)
{
static_cast<QTableView*>(ptr)->setGridStyle(static_cast<Qt::PenStyle>(style));
}
void QTableView_SetSelection(void* ptr, void* rect, int flags)
{
static_cast<QTableView*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
}
void QTableView_SetSelectionDefault(void* ptr, void* rect, int flags)
{
static_cast<QTableView*>(ptr)->QTableView::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
}
void QTableView_SetShowGrid(void* ptr, int 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, int on)
{
static_cast<QTableView*>(ptr)->setWordWrap(on != 0);
}
int QTableView_ShowGrid(void* ptr)
{
return static_cast<QTableView*>(ptr)->showGrid();
}
int 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)));
}
int QTableView_IsColumnHidden(void* ptr, int column)
{
return static_cast<QTableView*>(ptr)->isColumnHidden(column);
}
int QTableView_IsIndexHidden(void* ptr, void* index)
{
return static_cast<QTableView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}
int QTableView_IsIndexHiddenDefault(void* ptr, void* index)
{
return static_cast<QTableView*>(ptr)->QTableView::isIndexHidden(*static_cast<QModelIndex*>(index));
}
int 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, int 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, int 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, int 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, int 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 new QSize(static_cast<QSize>(static_cast<QTableView*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QTableView*>(ptr)->viewportSizeHint()).height());
}
void* QTableView_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTableView*>(ptr)->QTableView::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QTableView*>(ptr)->QTableView::viewportSizeHint()).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));
}
int QTableView_ViewportEvent(void* ptr, void* event)
{
return static_cast<QTableView*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int 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, int 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, int 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));
}
int QTableView_Edit2(void* ptr, void* index, int trigger, void* event)
{
return static_cast<QTableView*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}
int QTableView_Edit2Default(void* ptr, void* index, int 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));
}
int QTableView_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QTableView*>(ptr)->focusNextPrevChild(next != 0);
}
int QTableView_FocusNextPrevChildDefault(void* ptr, int 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, int query)
{
return new QVariant(static_cast<QTableView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QTableView_InputMethodQueryDefault(void* ptr, int 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, int hint)
{
static_cast<QTableView*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}
void QTableView_ScrollToDefault(void* ptr, void* index, int 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();
}
int QTableView_SelectionCommand(void* ptr, void* index, void* event)
{
return static_cast<QTableView*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}
int 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, int supportedActions)
{
static_cast<QTableView*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}
void QTableView_StartDragDefault(void* ptr, int 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 new QRect(static_cast<QRect>(static_cast<QTableView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QTableView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QTableView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QTableView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).height());
}
void* QTableView_VisualRectDefault(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QTableView*>(ptr)->QTableView::visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QTableView*>(ptr)->QTableView::visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QTableView*>(ptr)->QTableView::visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QTableView*>(ptr)->QTableView::visualRect(*static_cast<QModelIndex*>(index))).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 new QSize(static_cast<QSize>(static_cast<QTableView*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTableView*>(ptr)->minimumSizeHint()).height());
}
void* QTableView_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTableView*>(ptr)->QTableView::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTableView*>(ptr)->QTableView::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QTableView*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QTableView*>(ptr)->sizeHint()).height());
}
void* QTableView_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTableView*>(ptr)->QTableView::sizeHint()).width(), static_cast<QSize>(static_cast<QTableView*>(ptr)->QTableView::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QTableView_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QTableView_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QTableView*>(ptr)->QTableView::setVisible(visible != 0);
}
void QTableView_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QTableView_SetWindowModifiedDefault(void* ptr, int 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));
}
int QTableView_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QTableView_HasHeightForWidth(void* ptr)
{
return static_cast<QTableView*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QTableView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTableView*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QTableView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTableView*>(ptr)->QTableView::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QTableView_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QTableView_SetHiddenDefault(void* ptr, int 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));
}
int QTableView_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QTableView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), row, column); };
void Signal_CellChanged(int row, int column) { callbackQTableWidget_CellChanged(this, this->objectName().toUtf8().data(), row, column); };
void Signal_CellClicked(int row, int column) { callbackQTableWidget_CellClicked(this, this->objectName().toUtf8().data(), row, column); };
void Signal_CellDoubleClicked(int row, int column) { callbackQTableWidget_CellDoubleClicked(this, this->objectName().toUtf8().data(), row, column); };
void Signal_CellEntered(int row, int column) { callbackQTableWidget_CellEntered(this, this->objectName().toUtf8().data(), row, column); };
void Signal_CellPressed(int row, int column) { callbackQTableWidget_CellPressed(this, this->objectName().toUtf8().data(), row, column); };
void clear() { callbackQTableWidget_Clear(this, this->objectName().toUtf8().data()); };
void clearContents() { callbackQTableWidget_ClearContents(this, this->objectName().toUtf8().data()); };
void Signal_CurrentCellChanged(int currentRow, int currentColumn, int previousRow, int previousColumn) { callbackQTableWidget_CurrentCellChanged(this, this->objectName().toUtf8().data(), currentRow, currentColumn, previousRow, previousColumn); };
void Signal_CurrentItemChanged(QTableWidgetItem * current, QTableWidgetItem * previous) { callbackQTableWidget_CurrentItemChanged(this, this->objectName().toUtf8().data(), current, previous); };
void dropEvent(QDropEvent * event) { callbackQTableWidget_DropEvent(this, this->objectName().toUtf8().data(), event); };
bool dropMimeData(int row, int column, const QMimeData * data, Qt::DropAction action) { return callbackQTableWidget_DropMimeData(this, this->objectName().toUtf8().data(), row, column, const_cast<QMimeData*>(data), action) != 0; };
void insertColumn(int column) { callbackQTableWidget_InsertColumn(this, this->objectName().toUtf8().data(), column); };
void insertRow(int row) { callbackQTableWidget_InsertRow(this, this->objectName().toUtf8().data(), row); };
void Signal_ItemActivated(QTableWidgetItem * item) { callbackQTableWidget_ItemActivated(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemChanged(QTableWidgetItem * item) { callbackQTableWidget_ItemChanged(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemClicked(QTableWidgetItem * item) { callbackQTableWidget_ItemClicked(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemDoubleClicked(QTableWidgetItem * item) { callbackQTableWidget_ItemDoubleClicked(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemEntered(QTableWidgetItem * item) { callbackQTableWidget_ItemEntered(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemPressed(QTableWidgetItem * item) { callbackQTableWidget_ItemPressed(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemSelectionChanged() { callbackQTableWidget_ItemSelectionChanged(this, this->objectName().toUtf8().data()); };
QStringList mimeTypes() const { return QString(callbackQTableWidget_MimeTypes(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data())).split("|", QString::SkipEmptyParts); };
void removeColumn(int column) { callbackQTableWidget_RemoveColumn(this, this->objectName().toUtf8().data(), column); };
void removeRow(int row) { callbackQTableWidget_RemoveRow(this, this->objectName().toUtf8().data(), row); };
void scrollToItem(const QTableWidgetItem * item, QAbstractItemView::ScrollHint hint) { callbackQTableWidget_ScrollToItem(this, this->objectName().toUtf8().data(), const_cast<QTableWidgetItem*>(item), hint); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQTableWidget_SupportedDropActions(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data())); };
QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQTableWidget_MoveCursor(this, this->objectName().toUtf8().data(), cursorAction, modifiers)); };
void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags flags) { callbackQTableWidget_SetSelection(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), flags); };
void setShowGrid(bool show) { callbackQTableWidget_SetShowGrid(this, this->objectName().toUtf8().data(), show); };
void columnCountChanged(int oldCount, int newCount) { callbackQTableWidget_ColumnCountChanged(this, this->objectName().toUtf8().data(), oldCount, newCount); };
void columnMoved(int column, int oldIndex, int newIndex) { callbackQTableWidget_ColumnMoved(this, this->objectName().toUtf8().data(), column, oldIndex, newIndex); };
void columnResized(int column, int oldWidth, int newWidth) { callbackQTableWidget_ColumnResized(this, this->objectName().toUtf8().data(), column, oldWidth, newWidth); };
void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQTableWidget_CurrentChanged(this, this->objectName().toUtf8().data(), new QModelIndex(current), new QModelIndex(previous)); };
void hideColumn(int column) { callbackQTableWidget_HideColumn(this, this->objectName().toUtf8().data(), column); };
void hideRow(int row) { callbackQTableWidget_HideRow(this, this->objectName().toUtf8().data(), row); };
int horizontalOffset() const { return callbackQTableWidget_HorizontalOffset(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data()); };
QModelIndex indexAt(const QPoint & pos) const { return *static_cast<QModelIndex*>(callbackQTableWidget_IndexAt(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(pos).x(), static_cast<QPoint>(pos).y()))); };
bool isIndexHidden(const QModelIndex & index) const { return callbackQTableWidget_IsIndexHidden(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data(), new QModelIndex(index)) != 0; };
void paintEvent(QPaintEvent * event) { callbackQTableWidget_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void resizeColumnToContents(int column) { callbackQTableWidget_ResizeColumnToContents(this, this->objectName().toUtf8().data(), column); };
void resizeColumnsToContents() { callbackQTableWidget_ResizeColumnsToContents(this, this->objectName().toUtf8().data()); };
void resizeRowToContents(int row) { callbackQTableWidget_ResizeRowToContents(this, this->objectName().toUtf8().data(), row); };
void resizeRowsToContents() { callbackQTableWidget_ResizeRowsToContents(this, this->objectName().toUtf8().data()); };
void rowCountChanged(int oldCount, int newCount) { callbackQTableWidget_RowCountChanged(this, this->objectName().toUtf8().data(), oldCount, newCount); };
void rowMoved(int row, int oldIndex, int newIndex) { callbackQTableWidget_RowMoved(this, this->objectName().toUtf8().data(), row, oldIndex, newIndex); };
void rowResized(int row, int oldHeight, int newHeight) { callbackQTableWidget_RowResized(this, this->objectName().toUtf8().data(), row, oldHeight, newHeight); };
void selectColumn(int column) { callbackQTableWidget_SelectColumn(this, this->objectName().toUtf8().data(), column); };
void selectRow(int row) { callbackQTableWidget_SelectRow(this, this->objectName().toUtf8().data(), row); };
void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQTableWidget_SelectionChanged(this, this->objectName().toUtf8().data(), new QItemSelection(selected), new QItemSelection(deselected)); };
void setModel(QAbstractItemModel * model) { callbackQTableWidget_SetModel(this, this->objectName().toUtf8().data(), model); };
void setRootIndex(const QModelIndex & index) { callbackQTableWidget_SetRootIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQTableWidget_SetSelectionModel(this, this->objectName().toUtf8().data(), selectionModel); };
void showColumn(int column) { callbackQTableWidget_ShowColumn(this, this->objectName().toUtf8().data(), column); };
void showRow(int row) { callbackQTableWidget_ShowRow(this, this->objectName().toUtf8().data(), row); };
int sizeHintForColumn(int column) const { return callbackQTableWidget_SizeHintForColumn(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data(), column); };
int sizeHintForRow(int row) const { return callbackQTableWidget_SizeHintForRow(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data(), row); };
void updateGeometries() { callbackQTableWidget_UpdateGeometries(this, this->objectName().toUtf8().data()); };
int verticalOffset() const { return callbackQTableWidget_VerticalOffset(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data()); };
QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQTableWidget_ViewOptions(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data())); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQTableWidget_ViewportSizeHint(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data())); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQTableWidget_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
bool viewportEvent(QEvent * event) { return callbackQTableWidget_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
void clearSelection() { callbackQTableWidget_ClearSelection(this, this->objectName().toUtf8().data()); };
void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQTableWidget_CloseEditor(this, this->objectName().toUtf8().data(), editor, hint); };
void commitData(QWidget * editor) { callbackQTableWidget_CommitData(this, this->objectName().toUtf8().data(), editor); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQTableWidget_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQTableWidget_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void edit(const QModelIndex & index) { callbackQTableWidget_Edit(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQTableWidget_Edit2(this, this->objectName().toUtf8().data(), new QModelIndex(index), trigger, event) != 0; };
void editorDestroyed(QObject * editor) { callbackQTableWidget_EditorDestroyed(this, this->objectName().toUtf8().data(), editor); };
void focusInEvent(QFocusEvent * event) { callbackQTableWidget_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQTableWidget_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * event) { callbackQTableWidget_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQTableWidget_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQTableWidget_InputMethodQuery(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQTableWidget_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyboardSearch(const QString & search) { callbackQTableWidget_KeyboardSearch(this, this->objectName().toUtf8().data(), search.toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQTableWidget_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQTableWidget_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQTableWidget_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQTableWidget_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void reset() { callbackQTableWidget_Reset(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQTableWidget_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQTableWidget_RowsAboutToBeRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQTableWidget_RowsInserted(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQTableWidget_ScrollTo(this, this->objectName().toUtf8().data(), new QModelIndex(index), hint); };
void scrollToBottom() { callbackQTableWidget_ScrollToBottom(this, this->objectName().toUtf8().data()); };
void scrollToTop() { callbackQTableWidget_ScrollToTop(this, this->objectName().toUtf8().data()); };
void selectAll() { callbackQTableWidget_SelectAll(this, this->objectName().toUtf8().data()); };
QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQTableWidget_SelectionCommand(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data(), new QModelIndex(index), const_cast<QEvent*>(event))); };
void setCurrentIndex(const QModelIndex & index) { callbackQTableWidget_SetCurrentIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void startDrag(Qt::DropActions supportedActions) { callbackQTableWidget_StartDrag(this, this->objectName().toUtf8().data(), supportedActions); };
void update(const QModelIndex & index) { callbackQTableWidget_Update(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQTableWidget_VisualRect(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data(), new QModelIndex(index))); };
QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQTableWidget_VisualRegionForSelection(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data(), new QItemSelection(selection))); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQTableWidget_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTableWidget_MinimumSizeHint(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data())); };
void scrollContentsBy(int dx, int dy) { callbackQTableWidget_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void setupViewport(QWidget * viewport) { callbackQTableWidget_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQTableWidget_SizeHint(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data())); };
void wheelEvent(QWheelEvent * e) { callbackQTableWidget_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void changeEvent(QEvent * ev) { callbackQTableWidget_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQTableWidget_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQTableWidget_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQTableWidget_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQTableWidget_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQTableWidget_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQTableWidget_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQTableWidget_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQTableWidget_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQTableWidget_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQTableWidget_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQTableWidget_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQTableWidget_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQTableWidget_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQTableWidget_HasHeightForWidth(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQTableWidget_HeightForWidth(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQTableWidget_Hide(this, this->objectName().toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * event) { callbackQTableWidget_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQTableWidget_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTableWidget_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQTableWidget_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQTableWidget_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQTableWidget_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQTableWidget_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQTableWidget_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQTableWidget_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQTableWidget_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQTableWidget_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQTableWidget_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQTableWidget_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQTableWidget_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void updateMicroFocus() { callbackQTableWidget_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQTableWidget_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQTableWidget_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQTableWidget_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQTableWidget_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTableWidget_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTableWidget_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTableWidget_MetaObject(const_cast<MyQTableWidget*>(this), this->objectName().toUtf8().data())); };
};
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));
}
int QTableWidget_DropMimeData(void* ptr, int row, int column, void* data, int action)
{
return static_cast<QTableWidget*>(ptr)->dropMimeData(row, column, static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action));
}
int QTableWidget_DropMimeDataDefault(void* ptr, int row, int column, void* data, int 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));
}
int 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 static_cast<QTableWidget*>(ptr)->mimeTypes().join("|").toUtf8().data();
}
char* QTableWidget_MimeTypesDefault(void* ptr)
{
return static_cast<QTableWidget*>(ptr)->QTableWidget::mimeTypes().join("|").toUtf8().data();
}
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, int 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, int 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, int 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, int 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, int order)
{
static_cast<QTableWidget*>(ptr)->sortItems(column, static_cast<Qt::SortOrder>(order));
}
int QTableWidget_SupportedDropActions(void* ptr)
{
return static_cast<QTableWidget*>(ptr)->supportedDropActions();
}
int 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 new QRect(static_cast<QRect>(static_cast<QTableWidget*>(ptr)->visualItemRect(static_cast<QTableWidgetItem*>(item))).x(), static_cast<QRect>(static_cast<QTableWidget*>(ptr)->visualItemRect(static_cast<QTableWidgetItem*>(item))).y(), static_cast<QRect>(static_cast<QTableWidget*>(ptr)->visualItemRect(static_cast<QTableWidgetItem*>(item))).width(), static_cast<QRect>(static_cast<QTableWidget*>(ptr)->visualItemRect(static_cast<QTableWidgetItem*>(item))).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, int cursorAction, int modifiers)
{
return new QModelIndex(static_cast<QTableWidget*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}
void* QTableWidget_MoveCursorDefault(void* ptr, int cursorAction, int 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, int flags)
{
static_cast<QTableWidget*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
}
void QTableWidget_SetSelectionDefault(void* ptr, void* rect, int flags)
{
static_cast<QTableWidget*>(ptr)->QTableWidget::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(flags));
}
void QTableWidget_SetShowGrid(void* ptr, int show)
{
QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setShowGrid", Q_ARG(bool, show != 0));
}
void QTableWidget_SetShowGridDefault(void* ptr, int 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)));
}
int QTableWidget_IsIndexHidden(void* ptr, void* index)
{
return static_cast<QTableWidget*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}
int 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 new QSize(static_cast<QSize>(static_cast<QTableWidget*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QTableWidget*>(ptr)->viewportSizeHint()).height());
}
void* QTableWidget_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTableWidget*>(ptr)->QTableWidget::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QTableWidget*>(ptr)->QTableWidget::viewportSizeHint()).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));
}
int QTableWidget_ViewportEvent(void* ptr, void* event)
{
return static_cast<QTableWidget*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int 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, int 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, int 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));
}
int QTableWidget_Edit2(void* ptr, void* index, int trigger, void* event)
{
return static_cast<QTableWidget*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}
int QTableWidget_Edit2Default(void* ptr, void* index, int 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));
}
int QTableWidget_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QTableWidget*>(ptr)->focusNextPrevChild(next != 0);
}
int QTableWidget_FocusNextPrevChildDefault(void* ptr, int 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, int query)
{
return new QVariant(static_cast<QTableWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QTableWidget_InputMethodQueryDefault(void* ptr, int 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, int hint)
{
static_cast<QTableWidget*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}
void QTableWidget_ScrollToDefault(void* ptr, void* index, int 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();
}
int QTableWidget_SelectionCommand(void* ptr, void* index, void* event)
{
return static_cast<QTableWidget*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}
int 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, int supportedActions)
{
static_cast<QTableWidget*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}
void QTableWidget_StartDragDefault(void* ptr, int 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 new QRect(static_cast<QRect>(static_cast<QTableWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QTableWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QTableWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QTableWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).height());
}
void* QTableWidget_VisualRectDefault(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QTableWidget*>(ptr)->QTableWidget::visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QTableWidget*>(ptr)->QTableWidget::visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QTableWidget*>(ptr)->QTableWidget::visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QTableWidget*>(ptr)->QTableWidget::visualRect(*static_cast<QModelIndex*>(index))).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 new QSize(static_cast<QSize>(static_cast<QTableWidget*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTableWidget*>(ptr)->minimumSizeHint()).height());
}
void* QTableWidget_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTableWidget*>(ptr)->QTableWidget::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTableWidget*>(ptr)->QTableWidget::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QTableWidget*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QTableWidget*>(ptr)->sizeHint()).height());
}
void* QTableWidget_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTableWidget*>(ptr)->QTableWidget::sizeHint()).width(), static_cast<QSize>(static_cast<QTableWidget*>(ptr)->QTableWidget::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QTableWidget_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QTableWidget_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QTableWidget*>(ptr)->QTableWidget::setVisible(visible != 0);
}
void QTableWidget_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QTableWidget_SetWindowModifiedDefault(void* ptr, int 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));
}
int QTableWidget_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QTableWidget_HasHeightForWidth(void* ptr)
{
return static_cast<QTableWidget*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QTableWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTableWidget*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QTableWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTableWidget*>(ptr)->QTableWidget::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QTableWidget_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QTableWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QTableWidget_SetHiddenDefault(void* ptr, int 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));
}
int QTableWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QTableWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
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), this->objectNameAbs().toUtf8().data())); };
QVariant data(int role) const { return *static_cast<QVariant*>(callbackQTableWidgetItem_Data(const_cast<MyQTableWidgetItem*>(this), this->objectNameAbs().toUtf8().data(), role)); };
void setData(int role, const QVariant & value) { callbackQTableWidgetItem_SetData(this, this->objectNameAbs().toUtf8().data(), role, new QVariant(value)); };
};
void QTableWidgetItem_SetFlags(void* ptr, int 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());
}
int 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));
}
int 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());
}
int 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, int 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, int 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 new QSize(static_cast<QSize>(static_cast<QTableWidgetItem*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QTableWidgetItem*>(ptr)->sizeHint()).height());
}
char* QTableWidgetItem_StatusTip(void* ptr)
{
return static_cast<QTableWidgetItem*>(ptr)->statusTip().toUtf8().data();
}
void* QTableWidgetItem_TableWidget(void* ptr)
{
return static_cast<QTableWidgetItem*>(ptr)->tableWidget();
}
char* QTableWidgetItem_Text(void* ptr)
{
return static_cast<QTableWidgetItem*>(ptr)->text().toUtf8().data();
}
int QTableWidgetItem_TextAlignment(void* ptr)
{
return static_cast<QTableWidgetItem*>(ptr)->textAlignment();
}
char* QTableWidgetItem_ToolTip(void* ptr)
{
return static_cast<QTableWidgetItem*>(ptr)->toolTip().toUtf8().data();
}
int QTableWidgetItem_Type(void* ptr)
{
return static_cast<QTableWidgetItem*>(ptr)->type();
}
char* QTableWidgetItem_WhatsThis(void* ptr)
{
return static_cast<QTableWidgetItem*>(ptr)->whatsThis().toUtf8().data();
}
void QTableWidgetItem_DestroyQTableWidgetItem(void* ptr)
{
static_cast<QTableWidgetItem*>(ptr)->~QTableWidgetItem();
}
char* QTableWidgetItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQTableWidgetItem*>(static_cast<QTableWidgetItem*>(ptr))) {
return static_cast<MyQTableWidgetItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QTableWidgetItem_BASE").toUtf8().data();
}
void QTableWidgetItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQTableWidgetItem*>(static_cast<QTableWidgetItem*>(ptr))) {
static_cast<MyQTableWidgetItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
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 new QPointF(static_cast<QPointF>(static_cast<QTapAndHoldGesture*>(ptr)->position()).x(), static_cast<QPointF>(static_cast<QTapAndHoldGesture*>(ptr)->position()).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));
}
int QTapAndHoldGesture_Event(void* ptr, void* e)
{
return static_cast<QTapAndHoldGesture*>(ptr)->event(static_cast<QEvent*>(e));
}
int QTapAndHoldGesture_EventDefault(void* ptr, void* e)
{
return static_cast<QTapAndHoldGesture*>(ptr)->QTapAndHoldGesture::event(static_cast<QEvent*>(e));
}
int QTapAndHoldGesture_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QTapAndHoldGesture*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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 new QPointF(static_cast<QPointF>(static_cast<QTapGesture*>(ptr)->position()).x(), static_cast<QPointF>(static_cast<QTapGesture*>(ptr)->position()).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));
}
int QTapGesture_Event(void* ptr, void* e)
{
return static_cast<QTapGesture*>(ptr)->event(static_cast<QEvent*>(e));
}
int QTapGesture_EventDefault(void* ptr, void* e)
{
return static_cast<QTapGesture*>(ptr)->QTapGesture::event(static_cast<QEvent*>(e));
}
int QTapGesture_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QTapGesture*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), new QUrl(name)); };
void Signal_AnchorClicked(const QUrl & link) { callbackQTextBrowser_AnchorClicked(this, this->objectName().toUtf8().data(), new QUrl(link)); };
void backward() { callbackQTextBrowser_Backward(this, this->objectName().toUtf8().data()); };
void Signal_BackwardAvailable(bool available) { callbackQTextBrowser_BackwardAvailable(this, this->objectName().toUtf8().data(), available); };
bool event(QEvent * e) { return callbackQTextBrowser_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool focusNextPrevChild(bool next) { return callbackQTextBrowser_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * ev) { callbackQTextBrowser_FocusOutEvent(this, this->objectName().toUtf8().data(), ev); };
void forward() { callbackQTextBrowser_Forward(this, this->objectName().toUtf8().data()); };
void Signal_ForwardAvailable(bool available) { callbackQTextBrowser_ForwardAvailable(this, this->objectName().toUtf8().data(), available); };
void Signal_Highlighted2(const QString & link) { callbackQTextBrowser_Highlighted2(this, this->objectName().toUtf8().data(), link.toUtf8().data()); };
void Signal_Highlighted(const QUrl & link) { callbackQTextBrowser_Highlighted(this, this->objectName().toUtf8().data(), new QUrl(link)); };
void Signal_HistoryChanged() { callbackQTextBrowser_HistoryChanged(this, this->objectName().toUtf8().data()); };
void home() { callbackQTextBrowser_Home(this, this->objectName().toUtf8().data()); };
void keyPressEvent(QKeyEvent * ev) { callbackQTextBrowser_KeyPressEvent(this, this->objectName().toUtf8().data(), ev); };
QVariant loadResource(int ty, const QUrl & name) { return *static_cast<QVariant*>(callbackQTextBrowser_LoadResource(this, this->objectName().toUtf8().data(), ty, new QUrl(name))); };
void mouseMoveEvent(QMouseEvent * e) { callbackQTextBrowser_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQTextBrowser_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQTextBrowser_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void paintEvent(QPaintEvent * e) { callbackQTextBrowser_PaintEvent(this, this->objectName().toUtf8().data(), e); };
void reload() { callbackQTextBrowser_Reload(this, this->objectName().toUtf8().data()); };
void Signal_SourceChanged(const QUrl & src) { callbackQTextBrowser_SourceChanged(this, this->objectName().toUtf8().data(), new QUrl(src)); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQTextBrowser_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
void redo() { callbackQTextBrowser_Redo(this, this->objectName().toUtf8().data()); };
void setFontWeight(int weight) { callbackQTextBrowser_SetFontWeight(this, this->objectName().toUtf8().data(), weight); };
void setHtml(const QString & text) { callbackQTextBrowser_SetHtml(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void zoomIn(int ran) { callbackQTextBrowser_ZoomIn(this, this->objectName().toUtf8().data(), ran); };
void zoomOut(int ran) { callbackQTextBrowser_ZoomOut(this, this->objectName().toUtf8().data(), ran); };
void append(const QString & text) { callbackQTextBrowser_Append(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
bool canInsertFromMimeData(const QMimeData * source) const { return callbackQTextBrowser_CanInsertFromMimeData(const_cast<MyQTextBrowser*>(this), this->objectName().toUtf8().data(), const_cast<QMimeData*>(source)) != 0; };
void changeEvent(QEvent * e) { callbackQTextBrowser_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void clear() { callbackQTextBrowser_Clear(this, this->objectName().toUtf8().data()); };
void copy() { callbackQTextBrowser_Copy(this, this->objectName().toUtf8().data()); };
QMimeData * createMimeDataFromSelection() const { return static_cast<QMimeData*>(callbackQTextBrowser_CreateMimeDataFromSelection(const_cast<MyQTextBrowser*>(this), this->objectName().toUtf8().data())); };
void cut() { callbackQTextBrowser_Cut(this, this->objectName().toUtf8().data()); };
void dragEnterEvent(QDragEnterEvent * e) { callbackQTextBrowser_DragEnterEvent(this, this->objectName().toUtf8().data(), e); };
void dragLeaveEvent(QDragLeaveEvent * e) { callbackQTextBrowser_DragLeaveEvent(this, this->objectName().toUtf8().data(), e); };
void dragMoveEvent(QDragMoveEvent * e) { callbackQTextBrowser_DragMoveEvent(this, this->objectName().toUtf8().data(), e); };
void dropEvent(QDropEvent * e) { callbackQTextBrowser_DropEvent(this, this->objectName().toUtf8().data(), e); };
void focusInEvent(QFocusEvent * e) { callbackQTextBrowser_FocusInEvent(this, this->objectName().toUtf8().data(), e); };
void inputMethodEvent(QInputMethodEvent * e) { callbackQTextBrowser_InputMethodEvent(this, this->objectName().toUtf8().data(), e); };
QVariant inputMethodQuery(Qt::InputMethodQuery property) const { return *static_cast<QVariant*>(callbackQTextBrowser_InputMethodQuery(const_cast<MyQTextBrowser*>(this), this->objectName().toUtf8().data(), property)); };
void insertFromMimeData(const QMimeData * source) { callbackQTextBrowser_InsertFromMimeData(this, this->objectName().toUtf8().data(), const_cast<QMimeData*>(source)); };
void insertHtml(const QString & text) { callbackQTextBrowser_InsertHtml(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void insertPlainText(const QString & text) { callbackQTextBrowser_InsertPlainText(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * e) { callbackQTextBrowser_KeyReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void mouseDoubleClickEvent(QMouseEvent * e) { callbackQTextBrowser_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), e); };
void paste() { callbackQTextBrowser_Paste(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * e) { callbackQTextBrowser_ResizeEvent(this, this->objectName().toUtf8().data(), e); };
void scrollContentsBy(int dx, int dy) { callbackQTextBrowser_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void scrollToAnchor(const QString & name) { callbackQTextBrowser_ScrollToAnchor(this, this->objectName().toUtf8().data(), name.toUtf8().data()); };
void selectAll() { callbackQTextBrowser_SelectAll(this, this->objectName().toUtf8().data()); };
void setAlignment(Qt::Alignment a) { callbackQTextBrowser_SetAlignment(this, this->objectName().toUtf8().data(), a); };
void setCurrentFont(const QFont & f) { callbackQTextBrowser_SetCurrentFont(this, this->objectName().toUtf8().data(), new QFont(f)); };
void setFontFamily(const QString & fontFamily) { callbackQTextBrowser_SetFontFamily(this, this->objectName().toUtf8().data(), fontFamily.toUtf8().data()); };
void setFontItalic(bool italic) { callbackQTextBrowser_SetFontItalic(this, this->objectName().toUtf8().data(), italic); };
void setFontPointSize(qreal s) { callbackQTextBrowser_SetFontPointSize(this, this->objectName().toUtf8().data(), static_cast<double>(s)); };
void setFontUnderline(bool underline) { callbackQTextBrowser_SetFontUnderline(this, this->objectName().toUtf8().data(), underline); };
void setPlainText(const QString & text) { callbackQTextBrowser_SetPlainText(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void setText(const QString & text) { callbackQTextBrowser_SetText(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void setTextBackgroundColor(const QColor & c) { callbackQTextBrowser_SetTextBackgroundColor(this, this->objectName().toUtf8().data(), new QColor(c)); };
void setTextColor(const QColor & c) { callbackQTextBrowser_SetTextColor(this, this->objectName().toUtf8().data(), new QColor(c)); };
void showEvent(QShowEvent * vqs) { callbackQTextBrowser_ShowEvent(this, this->objectName().toUtf8().data(), vqs); };
void undo() { callbackQTextBrowser_Undo(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * e) { callbackQTextBrowser_WheelEvent(this, this->objectName().toUtf8().data(), e); };
bool viewportEvent(QEvent * event) { return callbackQTextBrowser_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTextBrowser_MinimumSizeHint(const_cast<MyQTextBrowser*>(this), this->objectName().toUtf8().data())); };
void setupViewport(QWidget * viewport) { callbackQTextBrowser_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQTextBrowser_SizeHint(const_cast<MyQTextBrowser*>(this), this->objectName().toUtf8().data())); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQTextBrowser_ViewportSizeHint(const_cast<MyQTextBrowser*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQTextBrowser_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQTextBrowser_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQTextBrowser_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQTextBrowser_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQTextBrowser_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQTextBrowser_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQTextBrowser_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQTextBrowser_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQTextBrowser_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQTextBrowser_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQTextBrowser_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQTextBrowser_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQTextBrowser_HasHeightForWidth(const_cast<MyQTextBrowser*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQTextBrowser_HeightForWidth(const_cast<MyQTextBrowser*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQTextBrowser_Hide(this, this->objectName().toUtf8().data()); };
void lower() { callbackQTextBrowser_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTextBrowser_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQTextBrowser_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQTextBrowser_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQTextBrowser_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQTextBrowser_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQTextBrowser_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQTextBrowser_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQTextBrowser_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQTextBrowser_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQTextBrowser_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQTextBrowser_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQTextBrowser_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQTextBrowser_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQTextBrowser_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQTextBrowser_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQTextBrowser_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQTextBrowser_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQTextBrowser_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQTextBrowser_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTextBrowser_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextBrowser_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextBrowser_MetaObject(const_cast<MyQTextBrowser*>(this), this->objectName().toUtf8().data())); };
};
int QTextBrowser_OpenExternalLinks(void* ptr)
{
return static_cast<QTextBrowser*>(ptr)->openExternalLinks();
}
int QTextBrowser_OpenLinks(void* ptr)
{
return static_cast<QTextBrowser*>(ptr)->openLinks();
}
char* QTextBrowser_SearchPaths(void* ptr)
{
return static_cast<QTextBrowser*>(ptr)->searchPaths().join("|").toUtf8().data();
}
void QTextBrowser_SetOpenExternalLinks(void* ptr, int open)
{
static_cast<QTextBrowser*>(ptr)->setOpenExternalLinks(open != 0);
}
void QTextBrowser_SetOpenLinks(void* ptr, int 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, int 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();
}
int QTextBrowser_Event(void* ptr, void* e)
{
return static_cast<QTextBrowser*>(ptr)->event(static_cast<QEvent*>(e));
}
int QTextBrowser_EventDefault(void* ptr, void* e)
{
return static_cast<QTextBrowser*>(ptr)->QTextBrowser::event(static_cast<QEvent*>(e));
}
int QTextBrowser_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QTextBrowser*>(ptr)->focusNextPrevChild(next != 0);
}
int QTextBrowser_FocusNextPrevChildDefault(void* ptr, int 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, int 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 static_cast<QTextBrowser*>(ptr)->historyTitle(i).toUtf8().data();
}
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();
}
int QTextBrowser_IsBackwardAvailable(void* ptr)
{
return static_cast<QTextBrowser*>(ptr)->isBackwardAvailable();
}
int 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));
}
int QTextBrowser_CanInsertFromMimeData(void* ptr, void* source)
{
return static_cast<QTextBrowser*>(ptr)->canInsertFromMimeData(static_cast<QMimeData*>(source));
}
int 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, int property)
{
return new QVariant(static_cast<QTextBrowser*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(property)));
}
void* QTextBrowser_InputMethodQueryDefault(void* ptr, int 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, int a)
{
QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setAlignment", Q_ARG(Qt::AlignmentFlag, static_cast<Qt::AlignmentFlag>(a)));
}
void QTextBrowser_SetAlignmentDefault(void* ptr, int 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, int italic)
{
QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setFontItalic", Q_ARG(bool, italic != 0));
}
void QTextBrowser_SetFontItalicDefault(void* ptr, int 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, static_cast<double>(s)));
}
void QTextBrowser_SetFontPointSizeDefault(void* ptr, double s)
{
static_cast<QTextBrowser*>(ptr)->QTextBrowser::setFontPointSize(static_cast<double>(s));
}
void QTextBrowser_SetFontUnderline(void* ptr, int underline)
{
QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setFontUnderline", Q_ARG(bool, underline != 0));
}
void QTextBrowser_SetFontUnderlineDefault(void* ptr, int 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));
}
int QTextBrowser_ViewportEvent(void* ptr, void* event)
{
return static_cast<QTextBrowser*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int QTextBrowser_ViewportEventDefault(void* ptr, void* event)
{
return static_cast<QTextBrowser*>(ptr)->QTextBrowser::viewportEvent(static_cast<QEvent*>(event));
}
void* QTextBrowser_MinimumSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTextBrowser*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTextBrowser*>(ptr)->minimumSizeHint()).height());
}
void* QTextBrowser_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTextBrowser*>(ptr)->QTextBrowser::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTextBrowser*>(ptr)->QTextBrowser::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QTextBrowser*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QTextBrowser*>(ptr)->sizeHint()).height());
}
void* QTextBrowser_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTextBrowser*>(ptr)->QTextBrowser::sizeHint()).width(), static_cast<QSize>(static_cast<QTextBrowser*>(ptr)->QTextBrowser::sizeHint()).height());
}
void* QTextBrowser_ViewportSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTextBrowser*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QTextBrowser*>(ptr)->viewportSizeHint()).height());
}
void* QTextBrowser_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTextBrowser*>(ptr)->QTextBrowser::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QTextBrowser*>(ptr)->QTextBrowser::viewportSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QTextBrowser_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QTextBrowser_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QTextBrowser*>(ptr)->QTextBrowser::setVisible(visible != 0);
}
void QTextBrowser_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QTextBrowser_SetWindowModifiedDefault(void* ptr, int 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));
}
int QTextBrowser_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QTextBrowser_HasHeightForWidth(void* ptr)
{
return static_cast<QTextBrowser*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QTextBrowser_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTextBrowser*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QTextBrowser_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTextBrowser*>(ptr)->QTextBrowser::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QTextBrowser_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QTextBrowser*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QTextBrowser_SetHiddenDefault(void* ptr, int 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));
}
int QTextBrowser_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QTextBrowser*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQTextEdit_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void redo() { callbackQTextEdit_Redo(this, this->objectName().toUtf8().data()); };
void setFontWeight(int weight) { callbackQTextEdit_SetFontWeight(this, this->objectName().toUtf8().data(), weight); };
void setHtml(const QString & text) { callbackQTextEdit_SetHtml(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void zoomIn(int ran) { callbackQTextEdit_ZoomIn(this, this->objectName().toUtf8().data(), ran); };
void zoomOut(int ran) { callbackQTextEdit_ZoomOut(this, this->objectName().toUtf8().data(), ran); };
void append(const QString & text) { callbackQTextEdit_Append(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
bool canInsertFromMimeData(const QMimeData * source) const { return callbackQTextEdit_CanInsertFromMimeData(const_cast<MyQTextEdit*>(this), this->objectName().toUtf8().data(), const_cast<QMimeData*>(source)) != 0; };
void changeEvent(QEvent * e) { callbackQTextEdit_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void clear() { callbackQTextEdit_Clear(this, this->objectName().toUtf8().data()); };
void copy() { callbackQTextEdit_Copy(this, this->objectName().toUtf8().data()); };
void Signal_CopyAvailable(bool yes) { callbackQTextEdit_CopyAvailable(this, this->objectName().toUtf8().data(), yes); };
QMimeData * createMimeDataFromSelection() const { return static_cast<QMimeData*>(callbackQTextEdit_CreateMimeDataFromSelection(const_cast<MyQTextEdit*>(this), this->objectName().toUtf8().data())); };
void Signal_CursorPositionChanged() { callbackQTextEdit_CursorPositionChanged(this, this->objectName().toUtf8().data()); };
void cut() { callbackQTextEdit_Cut(this, this->objectName().toUtf8().data()); };
void dragEnterEvent(QDragEnterEvent * e) { callbackQTextEdit_DragEnterEvent(this, this->objectName().toUtf8().data(), e); };
void dragLeaveEvent(QDragLeaveEvent * e) { callbackQTextEdit_DragLeaveEvent(this, this->objectName().toUtf8().data(), e); };
void dragMoveEvent(QDragMoveEvent * e) { callbackQTextEdit_DragMoveEvent(this, this->objectName().toUtf8().data(), e); };
void dropEvent(QDropEvent * e) { callbackQTextEdit_DropEvent(this, this->objectName().toUtf8().data(), e); };
void focusInEvent(QFocusEvent * e) { callbackQTextEdit_FocusInEvent(this, this->objectName().toUtf8().data(), e); };
bool focusNextPrevChild(bool next) { return callbackQTextEdit_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * e) { callbackQTextEdit_FocusOutEvent(this, this->objectName().toUtf8().data(), e); };
void inputMethodEvent(QInputMethodEvent * e) { callbackQTextEdit_InputMethodEvent(this, this->objectName().toUtf8().data(), e); };
QVariant inputMethodQuery(Qt::InputMethodQuery property) const { return *static_cast<QVariant*>(callbackQTextEdit_InputMethodQuery(const_cast<MyQTextEdit*>(this), this->objectName().toUtf8().data(), property)); };
void insertFromMimeData(const QMimeData * source) { callbackQTextEdit_InsertFromMimeData(this, this->objectName().toUtf8().data(), const_cast<QMimeData*>(source)); };
void insertHtml(const QString & text) { callbackQTextEdit_InsertHtml(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void insertPlainText(const QString & text) { callbackQTextEdit_InsertPlainText(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void keyPressEvent(QKeyEvent * e) { callbackQTextEdit_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void keyReleaseEvent(QKeyEvent * e) { callbackQTextEdit_KeyReleaseEvent(this, this->objectName().toUtf8().data(), e); };
QVariant loadResource(int ty, const QUrl & name) { return *static_cast<QVariant*>(callbackQTextEdit_LoadResource(this, this->objectName().toUtf8().data(), ty, new QUrl(name))); };
void mouseDoubleClickEvent(QMouseEvent * e) { callbackQTextEdit_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), e); };
void mouseMoveEvent(QMouseEvent * e) { callbackQTextEdit_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mousePressEvent(QMouseEvent * e) { callbackQTextEdit_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQTextEdit_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void paste() { callbackQTextEdit_Paste(this, this->objectName().toUtf8().data()); };
void Signal_RedoAvailable(bool available) { callbackQTextEdit_RedoAvailable(this, this->objectName().toUtf8().data(), available); };
void resizeEvent(QResizeEvent * e) { callbackQTextEdit_ResizeEvent(this, this->objectName().toUtf8().data(), e); };
void scrollContentsBy(int dx, int dy) { callbackQTextEdit_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void scrollToAnchor(const QString & name) { callbackQTextEdit_ScrollToAnchor(this, this->objectName().toUtf8().data(), name.toUtf8().data()); };
void selectAll() { callbackQTextEdit_SelectAll(this, this->objectName().toUtf8().data()); };
void Signal_SelectionChanged() { callbackQTextEdit_SelectionChanged(this, this->objectName().toUtf8().data()); };
void setAlignment(Qt::Alignment a) { callbackQTextEdit_SetAlignment(this, this->objectName().toUtf8().data(), a); };
void setCurrentFont(const QFont & f) { callbackQTextEdit_SetCurrentFont(this, this->objectName().toUtf8().data(), new QFont(f)); };
void setFontFamily(const QString & fontFamily) { callbackQTextEdit_SetFontFamily(this, this->objectName().toUtf8().data(), fontFamily.toUtf8().data()); };
void setFontItalic(bool italic) { callbackQTextEdit_SetFontItalic(this, this->objectName().toUtf8().data(), italic); };
void setFontPointSize(qreal s) { callbackQTextEdit_SetFontPointSize(this, this->objectName().toUtf8().data(), static_cast<double>(s)); };
void setFontUnderline(bool underline) { callbackQTextEdit_SetFontUnderline(this, this->objectName().toUtf8().data(), underline); };
void setPlainText(const QString & text) { callbackQTextEdit_SetPlainText(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void setText(const QString & text) { callbackQTextEdit_SetText(this, this->objectName().toUtf8().data(), text.toUtf8().data()); };
void setTextBackgroundColor(const QColor & c) { callbackQTextEdit_SetTextBackgroundColor(this, this->objectName().toUtf8().data(), new QColor(c)); };
void setTextColor(const QColor & c) { callbackQTextEdit_SetTextColor(this, this->objectName().toUtf8().data(), new QColor(c)); };
void showEvent(QShowEvent * vqs) { callbackQTextEdit_ShowEvent(this, this->objectName().toUtf8().data(), vqs); };
void Signal_TextChanged() { callbackQTextEdit_TextChanged(this, this->objectName().toUtf8().data()); };
void undo() { callbackQTextEdit_Undo(this, this->objectName().toUtf8().data()); };
void Signal_UndoAvailable(bool available) { callbackQTextEdit_UndoAvailable(this, this->objectName().toUtf8().data(), available); };
void wheelEvent(QWheelEvent * e) { callbackQTextEdit_WheelEvent(this, this->objectName().toUtf8().data(), e); };
bool viewportEvent(QEvent * event) { return callbackQTextEdit_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTextEdit_MinimumSizeHint(const_cast<MyQTextEdit*>(this), this->objectName().toUtf8().data())); };
void setupViewport(QWidget * viewport) { callbackQTextEdit_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQTextEdit_SizeHint(const_cast<MyQTextEdit*>(this), this->objectName().toUtf8().data())); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQTextEdit_ViewportSizeHint(const_cast<MyQTextEdit*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQTextEdit_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQTextEdit_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQTextEdit_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQTextEdit_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQTextEdit_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQTextEdit_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQTextEdit_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQTextEdit_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQTextEdit_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQTextEdit_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQTextEdit_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQTextEdit_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQTextEdit_HasHeightForWidth(const_cast<MyQTextEdit*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQTextEdit_HeightForWidth(const_cast<MyQTextEdit*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQTextEdit_Hide(this, this->objectName().toUtf8().data()); };
void lower() { callbackQTextEdit_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTextEdit_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQTextEdit_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQTextEdit_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQTextEdit_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQTextEdit_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQTextEdit_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQTextEdit_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQTextEdit_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQTextEdit_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQTextEdit_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQTextEdit_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQTextEdit_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQTextEdit_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQTextEdit_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQTextEdit_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQTextEdit_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQTextEdit_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQTextEdit_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQTextEdit_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTextEdit_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextEdit_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextEdit_MetaObject(const_cast<MyQTextEdit*>(this), this->objectName().toUtf8().data())); };
};
int QTextEdit_AcceptRichText(void* ptr)
{
return static_cast<QTextEdit*>(ptr)->acceptRichText();
}
int 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();
}
int QTextEdit_Find2(void* ptr, void* exp, int options)
{
return static_cast<QTextEdit*>(ptr)->find(*static_cast<QRegExp*>(exp), static_cast<QTextDocument::FindFlag>(options));
}
int QTextEdit_IsReadOnly(void* ptr)
{
return static_cast<QTextEdit*>(ptr)->isReadOnly();
}
int QTextEdit_LineWrapColumnOrWidth(void* ptr)
{
return static_cast<QTextEdit*>(ptr)->lineWrapColumnOrWidth();
}
int QTextEdit_LineWrapMode(void* ptr)
{
return static_cast<QTextEdit*>(ptr)->lineWrapMode();
}
int 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 static_cast<QTextEdit*>(ptr)->placeholderText().toUtf8().data();
}
void QTextEdit_Redo(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "redo");
}
void QTextEdit_SetAcceptRichText(void* ptr, int accept)
{
static_cast<QTextEdit*>(ptr)->setAcceptRichText(accept != 0);
}
void QTextEdit_SetAutoFormatting(void* ptr, int 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, int mode)
{
static_cast<QTextEdit*>(ptr)->setLineWrapMode(static_cast<QTextEdit::LineWrapMode>(mode));
}
void QTextEdit_SetOverwriteMode(void* ptr, int 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, int ro)
{
static_cast<QTextEdit*>(ptr)->setReadOnly(ro != 0);
}
void QTextEdit_SetTabChangesFocus(void* ptr, int 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, int flags)
{
static_cast<QTextEdit*>(ptr)->setTextInteractionFlags(static_cast<Qt::TextInteractionFlag>(flags));
}
void QTextEdit_SetWordWrapMode(void* ptr, int policy)
{
static_cast<QTextEdit*>(ptr)->setWordWrapMode(static_cast<QTextOption::WrapMode>(policy));
}
int QTextEdit_TabChangesFocus(void* ptr)
{
return static_cast<QTextEdit*>(ptr)->tabChangesFocus();
}
int QTextEdit_TabStopWidth(void* ptr)
{
return static_cast<QTextEdit*>(ptr)->tabStopWidth();
}
int QTextEdit_TextInteractionFlags(void* ptr)
{
return static_cast<QTextEdit*>(ptr)->textInteractionFlags();
}
char* QTextEdit_ToHtml(void* ptr)
{
return static_cast<QTextEdit*>(ptr)->toHtml().toUtf8().data();
}
int 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));
}
int QTextEdit_Alignment(void* ptr)
{
return static_cast<QTextEdit*>(ptr)->alignment();
}
char* QTextEdit_AnchorAt(void* ptr, void* pos)
{
return static_cast<QTextEdit*>(ptr)->anchorAt(*static_cast<QPoint*>(pos)).toUtf8().data();
}
void QTextEdit_Append(void* ptr, char* text)
{
QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "append", Q_ARG(QString, QString(text)));
}
int QTextEdit_CanInsertFromMimeData(void* ptr, void* source)
{
return static_cast<QTextEdit*>(ptr)->canInsertFromMimeData(static_cast<QMimeData*>(source));
}
int QTextEdit_CanInsertFromMimeDataDefault(void* ptr, void* source)
{
return static_cast<QTextEdit*>(ptr)->QTextEdit::canInsertFromMimeData(static_cast<QMimeData*>(source));
}
int 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, int 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_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 new QRect(static_cast<QRect>(static_cast<QTextEdit*>(ptr)->cursorRect()).x(), static_cast<QRect>(static_cast<QTextEdit*>(ptr)->cursorRect()).y(), static_cast<QRect>(static_cast<QTextEdit*>(ptr)->cursorRect()).width(), static_cast<QRect>(static_cast<QTextEdit*>(ptr)->cursorRect()).height());
}
void* QTextEdit_CursorRect(void* ptr, void* cursor)
{
return new QRect(static_cast<QRect>(static_cast<QTextEdit*>(ptr)->cursorRect(*static_cast<QTextCursor*>(cursor))).x(), static_cast<QRect>(static_cast<QTextEdit*>(ptr)->cursorRect(*static_cast<QTextCursor*>(cursor))).y(), static_cast<QRect>(static_cast<QTextEdit*>(ptr)->cursorRect(*static_cast<QTextCursor*>(cursor))).width(), static_cast<QRect>(static_cast<QTextEdit*>(ptr)->cursorRect(*static_cast<QTextCursor*>(cursor))).height());
}
void QTextEdit_Cut(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "cut");
}
char* QTextEdit_DocumentTitle(void* ptr)
{
return static_cast<QTextEdit*>(ptr)->documentTitle().toUtf8().data();
}
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();
}
int QTextEdit_Find(void* ptr, char* exp, int 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));
}
int QTextEdit_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QTextEdit*>(ptr)->focusNextPrevChild(next != 0);
}
int QTextEdit_FocusNextPrevChildDefault(void* ptr, int 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 static_cast<QTextEdit*>(ptr)->fontFamily().toUtf8().data();
}
int QTextEdit_FontItalic(void* ptr)
{
return static_cast<QTextEdit*>(ptr)->fontItalic();
}
double QTextEdit_FontPointSize(void* ptr)
{
return static_cast<double>(static_cast<QTextEdit*>(ptr)->fontPointSize());
}
int 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, int property)
{
return new QVariant(static_cast<QTextEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(property)));
}
void* QTextEdit_InputMethodQueryDefault(void* ptr, int 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)));
}
int 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, int operation, int 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, int 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, int 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, int 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, static_cast<double>(s)));
}
void QTextEdit_SetFontUnderline(void* ptr, int 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, int 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 static_cast<QTextEdit*>(ptr)->toPlainText().toUtf8().data();
}
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, int 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();
}
int QTextEdit_ViewportEvent(void* ptr, void* event)
{
return static_cast<QTextEdit*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int QTextEdit_ViewportEventDefault(void* ptr, void* event)
{
return static_cast<QTextEdit*>(ptr)->QTextEdit::viewportEvent(static_cast<QEvent*>(event));
}
void* QTextEdit_MinimumSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTextEdit*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTextEdit*>(ptr)->minimumSizeHint()).height());
}
void* QTextEdit_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTextEdit*>(ptr)->QTextEdit::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTextEdit*>(ptr)->QTextEdit::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QTextEdit*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QTextEdit*>(ptr)->sizeHint()).height());
}
void* QTextEdit_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTextEdit*>(ptr)->QTextEdit::sizeHint()).width(), static_cast<QSize>(static_cast<QTextEdit*>(ptr)->QTextEdit::sizeHint()).height());
}
void* QTextEdit_ViewportSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTextEdit*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QTextEdit*>(ptr)->viewportSizeHint()).height());
}
void* QTextEdit_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTextEdit*>(ptr)->QTextEdit::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QTextEdit*>(ptr)->QTextEdit::viewportSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QTextEdit_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QTextEdit_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QTextEdit*>(ptr)->QTextEdit::setVisible(visible != 0);
}
void QTextEdit_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QTextEdit_SetWindowModifiedDefault(void* ptr, int 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));
}
int QTextEdit_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QTextEdit_HasHeightForWidth(void* ptr)
{
return static_cast<QTextEdit*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QTextEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTextEdit*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QTextEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTextEdit*>(ptr)->QTextEdit::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QTextEdit_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QTextEdit_SetHiddenDefault(void* ptr, int 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));
}
int QTextEdit_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QTextEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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(int horizontalRule, int verticalRule)
{
return new QTileRules(static_cast<Qt::TileRule>(horizontalRule), static_cast<Qt::TileRule>(verticalRule));
}
void* QTileRules_NewQTileRules2(int rule)
{
return new QTileRules(static_cast<Qt::TileRule>(rule));
}
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_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_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_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));
}
int QTimeEdit_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QTimeEdit*>(ptr)->focusNextPrevChild(next != 0);
}
int QTimeEdit_FocusNextPrevChildDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QTimeEdit*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QTimeEdit*>(ptr)->sizeHint()).height());
}
void* QTimeEdit_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTimeEdit*>(ptr)->QTimeEdit::sizeHint()).width(), static_cast<QSize>(static_cast<QTimeEdit*>(ptr)->QTimeEdit::sizeHint()).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);
}
int QTimeEdit_StepEnabled(void* ptr)
{
return static_cast<QTimeEdit*>(ptr)->stepEnabled();
}
int QTimeEdit_StepEnabledDefault(void* ptr)
{
return static_cast<QTimeEdit*>(ptr)->QTimeEdit::stepEnabled();
}
char* QTimeEdit_TextFromDateTime(void* ptr, void* dateTime)
{
return static_cast<QTimeEdit*>(ptr)->textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8().data();
}
char* QTimeEdit_TextFromDateTimeDefault(void* ptr, void* dateTime)
{
return static_cast<QTimeEdit*>(ptr)->QTimeEdit::textFromDateTime(*static_cast<QDateTime*>(dateTime)).toUtf8().data();
}
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, int query)
{
return new QVariant(static_cast<QTimeEdit*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QTimeEdit_InputMethodQueryDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QTimeEdit*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTimeEdit*>(ptr)->minimumSizeHint()).height());
}
void* QTimeEdit_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTimeEdit*>(ptr)->QTimeEdit::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTimeEdit*>(ptr)->QTimeEdit::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QTimeEdit_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QTimeEdit_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QTimeEdit*>(ptr)->QTimeEdit::setVisible(visible != 0);
}
void QTimeEdit_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QTimeEdit_SetWindowModifiedDefault(void* ptr, int 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));
}
int QTimeEdit_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QTimeEdit_CloseDefault(void* ptr)
{
return static_cast<QTimeEdit*>(ptr)->QTimeEdit::close();
}
int QTimeEdit_HasHeightForWidth(void* ptr)
{
return static_cast<QTimeEdit*>(ptr)->hasHeightForWidth();
}
int 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));
}
int QTimeEdit_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTimeEdit*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QTimeEdit_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTimeEdit*>(ptr)->QTimeEdit::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QTimeEdit_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QTimeEdit*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QTimeEdit_SetHiddenDefault(void* ptr, int 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));
}
int QTimeEdit_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QTimeEdit*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), new QSize(static_cast<QSize>(iconSize).width(), static_cast<QSize>(iconSize).height())); };
void setToolButtonStyle(Qt::ToolButtonStyle toolButtonStyle) { callbackQToolBar_SetToolButtonStyle(this, this->objectName().toUtf8().data(), toolButtonStyle); };
void actionEvent(QActionEvent * event) { callbackQToolBar_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_ActionTriggered(QAction * action) { callbackQToolBar_ActionTriggered(this, this->objectName().toUtf8().data(), action); };
void Signal_AllowedAreasChanged(Qt::ToolBarAreas allowedAreas) { callbackQToolBar_AllowedAreasChanged(this, this->objectName().toUtf8().data(), allowedAreas); };
void changeEvent(QEvent * event) { callbackQToolBar_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_IconSizeChanged(const QSize & iconSize) { callbackQToolBar_IconSizeChanged(this, this->objectName().toUtf8().data(), new QSize(static_cast<QSize>(iconSize).width(), static_cast<QSize>(iconSize).height())); };
void Signal_MovableChanged(bool movable) { callbackQToolBar_MovableChanged(this, this->objectName().toUtf8().data(), movable); };
void Signal_OrientationChanged(Qt::Orientation orientation) { callbackQToolBar_OrientationChanged(this, this->objectName().toUtf8().data(), orientation); };
void paintEvent(QPaintEvent * event) { callbackQToolBar_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_ToolButtonStyleChanged(Qt::ToolButtonStyle toolButtonStyle) { callbackQToolBar_ToolButtonStyleChanged(this, this->objectName().toUtf8().data(), toolButtonStyle); };
void Signal_TopLevelChanged(bool topLevel) { callbackQToolBar_TopLevelChanged(this, this->objectName().toUtf8().data(), topLevel); };
void Signal_VisibilityChanged(bool visible) { callbackQToolBar_VisibilityChanged(this, this->objectName().toUtf8().data(), visible); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQToolBar_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQToolBar_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQToolBar_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQToolBar_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQToolBar_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQToolBar_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQToolBar_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQToolBar_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQToolBar_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQToolBar_MinimumSizeHint(const_cast<MyQToolBar*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQToolBar_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQToolBar_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQToolBar_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQToolBar_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQToolBar_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQToolBar_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQToolBar_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQToolBar_SizeHint(const_cast<MyQToolBar*>(this), this->objectName().toUtf8().data())); };
bool close() { return callbackQToolBar_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQToolBar_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQToolBar_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQToolBar_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQToolBar_HasHeightForWidth(const_cast<MyQToolBar*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQToolBar_HeightForWidth(const_cast<MyQToolBar*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQToolBar_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQToolBar_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQToolBar_InputMethodQuery(const_cast<MyQToolBar*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQToolBar_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQToolBar_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQToolBar_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQToolBar_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQToolBar_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQToolBar_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQToolBar_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQToolBar_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQToolBar_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQToolBar_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQToolBar_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQToolBar_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQToolBar_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQToolBar_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQToolBar_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQToolBar_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQToolBar_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQToolBar_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQToolBar_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQToolBar_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQToolBar_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQToolBar_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQToolBar_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQToolBar_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQToolBar_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQToolBar_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQToolBar_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQToolBar_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQToolBar_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQToolBar_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQToolBar_MetaObject(const_cast<MyQToolBar*>(this), this->objectName().toUtf8().data())); };
};
int QToolBar_AllowedAreas(void* ptr)
{
return static_cast<QToolBar*>(ptr)->allowedAreas();
}
void* QToolBar_IconSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QToolBar*>(ptr)->iconSize()).width(), static_cast<QSize>(static_cast<QToolBar*>(ptr)->iconSize()).height());
}
int QToolBar_IsFloatable(void* ptr)
{
return static_cast<QToolBar*>(ptr)->isFloatable();
}
int QToolBar_IsFloating(void* ptr)
{
return static_cast<QToolBar*>(ptr)->isFloating();
}
int QToolBar_IsMovable(void* ptr)
{
return static_cast<QToolBar*>(ptr)->isMovable();
}
int QToolBar_Orientation(void* ptr)
{
return static_cast<QToolBar*>(ptr)->orientation();
}
void QToolBar_SetAllowedAreas(void* ptr, int areas)
{
static_cast<QToolBar*>(ptr)->setAllowedAreas(static_cast<Qt::ToolBarArea>(areas));
}
void QToolBar_SetFloatable(void* ptr, int 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, int movable)
{
static_cast<QToolBar*>(ptr)->setMovable(movable != 0);
}
void QToolBar_SetOrientation(void* ptr, int orientation)
{
static_cast<QToolBar*>(ptr)->setOrientation(static_cast<Qt::Orientation>(orientation));
}
void QToolBar_SetToolButtonStyle(void* ptr, int toolButtonStyle)
{
QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setToolButtonStyle", Q_ARG(Qt::ToolButtonStyle, static_cast<Qt::ToolButtonStyle>(toolButtonStyle)));
}
int 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, int 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();
}
int 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));
}
int QToolBar_IsAreaAllowed(void* ptr, int 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, int 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, int 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, int 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, int 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, int 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 new QSize(static_cast<QSize>(static_cast<QToolBar*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QToolBar*>(ptr)->minimumSizeHint()).height());
}
void* QToolBar_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QToolBar*>(ptr)->QToolBar::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QToolBar*>(ptr)->QToolBar::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QToolBar_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QToolBar_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QToolBar*>(ptr)->QToolBar::setVisible(visible != 0);
}
void QToolBar_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QToolBar_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QToolBar*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QToolBar*>(ptr)->sizeHint()).height());
}
void* QToolBar_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QToolBar*>(ptr)->QToolBar::sizeHint()).width(), static_cast<QSize>(static_cast<QToolBar*>(ptr)->QToolBar::sizeHint()).height());
}
int QToolBar_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QToolBar_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QToolBar*>(ptr)->focusNextPrevChild(next != 0);
}
int QToolBar_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QToolBar*>(ptr)->QToolBar::focusNextPrevChild(next != 0);
}
int QToolBar_HasHeightForWidth(void* ptr)
{
return static_cast<QToolBar*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QToolBar*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QToolBar_InputMethodQueryDefault(void* ptr, int 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));
}
int QToolBar_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QToolBar*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QToolBar_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QToolBar*>(ptr)->QToolBar::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QToolBar_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QToolBar*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QToolBar_SetHiddenDefault(void* ptr, int 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));
}
int QToolBar_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QToolBar*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), index); };
void changeEvent(QEvent * ev) { callbackQToolBox_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void Signal_CurrentChanged(int index) { callbackQToolBox_CurrentChanged(this, this->objectName().toUtf8().data(), index); };
void itemInserted(int index) { callbackQToolBox_ItemInserted(this, this->objectName().toUtf8().data(), index); };
void itemRemoved(int index) { callbackQToolBox_ItemRemoved(this, this->objectName().toUtf8().data(), index); };
void setCurrentWidget(QWidget * widget) { callbackQToolBox_SetCurrentWidget(this, this->objectName().toUtf8().data(), widget); };
void showEvent(QShowEvent * e) { callbackQToolBox_ShowEvent(this, this->objectName().toUtf8().data(), e); };
void paintEvent(QPaintEvent * vqp) { callbackQToolBox_PaintEvent(this, this->objectName().toUtf8().data(), vqp); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQToolBox_SizeHint(const_cast<MyQToolBox*>(this), this->objectName().toUtf8().data())); };
void actionEvent(QActionEvent * event) { callbackQToolBox_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQToolBox_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQToolBox_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQToolBox_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQToolBox_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQToolBox_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQToolBox_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQToolBox_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQToolBox_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQToolBox_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQToolBox_MinimumSizeHint(const_cast<MyQToolBox*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQToolBox_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQToolBox_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQToolBox_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQToolBox_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQToolBox_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQToolBox_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
bool close() { return callbackQToolBox_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQToolBox_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQToolBox_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQToolBox_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQToolBox_HasHeightForWidth(const_cast<MyQToolBox*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQToolBox_HeightForWidth(const_cast<MyQToolBox*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQToolBox_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQToolBox_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQToolBox_InputMethodQuery(const_cast<MyQToolBox*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQToolBox_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQToolBox_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQToolBox_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQToolBox_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQToolBox_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQToolBox_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQToolBox_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQToolBox_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQToolBox_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQToolBox_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQToolBox_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQToolBox_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQToolBox_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQToolBox_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQToolBox_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQToolBox_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQToolBox_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQToolBox_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQToolBox_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQToolBox_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQToolBox_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQToolBox_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQToolBox_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQToolBox_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQToolBox_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQToolBox_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQToolBox_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQToolBox_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQToolBox_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQToolBox_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQToolBox_MetaObject(const_cast<MyQToolBox*>(this), this->objectName().toUtf8().data())); };
};
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, int 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();
}
int 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));
}
int 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 static_cast<QToolBox*>(ptr)->itemText(index).toUtf8().data();
}
char* QToolBox_ItemToolTip(void* ptr, int index)
{
return static_cast<QToolBox*>(ptr)->itemToolTip(index).toUtf8().data();
}
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, int 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 new QSize(static_cast<QSize>(static_cast<QToolBox*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QToolBox*>(ptr)->sizeHint()).height());
}
void* QToolBox_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QToolBox*>(ptr)->QToolBox::sizeHint()).width(), static_cast<QSize>(static_cast<QToolBox*>(ptr)->QToolBox::sizeHint()).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 new QSize(static_cast<QSize>(static_cast<QToolBox*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QToolBox*>(ptr)->minimumSizeHint()).height());
}
void* QToolBox_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QToolBox*>(ptr)->QToolBox::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QToolBox*>(ptr)->QToolBox::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QToolBox_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QToolBox_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QToolBox*>(ptr)->QToolBox::setVisible(visible != 0);
}
void QToolBox_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QToolBox_SetWindowModifiedDefault(void* ptr, int 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));
}
int QToolBox_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QToolBox_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QToolBox*>(ptr)->focusNextPrevChild(next != 0);
}
int QToolBox_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QToolBox*>(ptr)->QToolBox::focusNextPrevChild(next != 0);
}
int QToolBox_HasHeightForWidth(void* ptr)
{
return static_cast<QToolBox*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QToolBox*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QToolBox_InputMethodQueryDefault(void* ptr, int 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));
}
int QToolBox_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QToolBox*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QToolBox_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QToolBox*>(ptr)->QToolBox::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QToolBox_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QToolBox*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QToolBox_SetHiddenDefault(void* ptr, int 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));
}
int QToolBox_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QToolBox*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), event); };
void setToolButtonStyle(Qt::ToolButtonStyle style) { callbackQToolButton_SetToolButtonStyle(this, this->objectName().toUtf8().data(), style); };
void actionEvent(QActionEvent * event) { callbackQToolButton_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void changeEvent(QEvent * e) { callbackQToolButton_ChangeEvent(this, this->objectName().toUtf8().data(), e); };
void enterEvent(QEvent * e) { callbackQToolButton_EnterEvent(this, this->objectName().toUtf8().data(), e); };
bool hitButton(const QPoint & pos) const { return callbackQToolButton_HitButton(const_cast<MyQToolButton*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(pos).x(), static_cast<QPoint>(pos).y())) != 0; };
void leaveEvent(QEvent * e) { callbackQToolButton_LeaveEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQToolButton_MinimumSizeHint(const_cast<MyQToolButton*>(this), this->objectName().toUtf8().data())); };
void mousePressEvent(QMouseEvent * e) { callbackQToolButton_MousePressEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQToolButton_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void nextCheckState() { callbackQToolButton_NextCheckState(this, this->objectName().toUtf8().data()); };
void setDefaultAction(QAction * action) { callbackQToolButton_SetDefaultAction(this, this->objectName().toUtf8().data(), action); };
void showMenu() { callbackQToolButton_ShowMenu(this, this->objectName().toUtf8().data()); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQToolButton_SizeHint(const_cast<MyQToolButton*>(this), this->objectName().toUtf8().data())); };
void Signal_Triggered(QAction * action) { callbackQToolButton_Triggered(this, this->objectName().toUtf8().data(), action); };
void setChecked(bool vbo) { callbackQToolButton_SetChecked(this, this->objectName().toUtf8().data(), vbo); };
void setIconSize(const QSize & size) { callbackQToolButton_SetIconSize(this, this->objectName().toUtf8().data(), new QSize(static_cast<QSize>(size).width(), static_cast<QSize>(size).height())); };
void toggle() { callbackQToolButton_Toggle(this, this->objectName().toUtf8().data()); };
void animateClick(int msec) { callbackQToolButton_AnimateClick(this, this->objectName().toUtf8().data(), msec); };
void checkStateSet() { callbackQToolButton_CheckStateSet(this, this->objectName().toUtf8().data()); };
void click() { callbackQToolButton_Click(this, this->objectName().toUtf8().data()); };
void focusInEvent(QFocusEvent * e) { callbackQToolButton_FocusInEvent(this, this->objectName().toUtf8().data(), e); };
void focusOutEvent(QFocusEvent * e) { callbackQToolButton_FocusOutEvent(this, this->objectName().toUtf8().data(), e); };
void keyPressEvent(QKeyEvent * e) { callbackQToolButton_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
void keyReleaseEvent(QKeyEvent * e) { callbackQToolButton_KeyReleaseEvent(this, this->objectName().toUtf8().data(), e); };
void mouseMoveEvent(QMouseEvent * e) { callbackQToolButton_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQToolButton_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQToolButton_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQToolButton_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQToolButton_DropEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQToolButton_HideEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQToolButton_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQToolButton_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQToolButton_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQToolButton_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQToolButton_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQToolButton_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQToolButton_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQToolButton_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQToolButton_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQToolButton_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQToolButton_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQToolButton_HasHeightForWidth(const_cast<MyQToolButton*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQToolButton_HeightForWidth(const_cast<MyQToolButton*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQToolButton_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQToolButton_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQToolButton_InputMethodQuery(const_cast<MyQToolButton*>(this), this->objectName().toUtf8().data(), query)); };
void lower() { callbackQToolButton_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQToolButton_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQToolButton_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQToolButton_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQToolButton_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQToolButton_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQToolButton_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQToolButton_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQToolButton_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQToolButton_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQToolButton_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQToolButton_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQToolButton_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQToolButton_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQToolButton_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQToolButton_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQToolButton_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQToolButton_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQToolButton_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQToolButton_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQToolButton_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQToolButton_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQToolButton_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQToolButton_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQToolButton_MetaObject(const_cast<MyQToolButton*>(this), this->objectName().toUtf8().data())); };
};
int QToolButton_ArrowType(void* ptr)
{
return static_cast<QToolButton*>(ptr)->arrowType();
}
int 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));
}
int QToolButton_PopupMode(void* ptr)
{
return static_cast<QToolButton*>(ptr)->popupMode();
}
void QToolButton_SetArrowType(void* ptr, int ty)
{
static_cast<QToolButton*>(ptr)->setArrowType(static_cast<Qt::ArrowType>(ty));
}
void QToolButton_SetAutoRaise(void* ptr, int enable)
{
static_cast<QToolButton*>(ptr)->setAutoRaise(enable != 0);
}
void QToolButton_SetPopupMode(void* ptr, int mode)
{
static_cast<QToolButton*>(ptr)->setPopupMode(static_cast<QToolButton::ToolButtonPopupMode>(mode));
}
void QToolButton_SetToolButtonStyle(void* ptr, int style)
{
QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setToolButtonStyle", Q_ARG(Qt::ToolButtonStyle, static_cast<Qt::ToolButtonStyle>(style)));
}
int 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));
}
int QToolButton_Event(void* ptr, void* event)
{
return static_cast<QToolButton*>(ptr)->event(static_cast<QEvent*>(event));
}
int QToolButton_HitButton(void* ptr, void* pos)
{
return static_cast<QToolButton*>(ptr)->hitButton(*static_cast<QPoint*>(pos));
}
int 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 new QSize(static_cast<QSize>(static_cast<QToolButton*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QToolButton*>(ptr)->minimumSizeHint()).height());
}
void* QToolButton_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QToolButton*>(ptr)->QToolButton::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QToolButton*>(ptr)->QToolButton::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QToolButton*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QToolButton*>(ptr)->sizeHint()).height());
}
void* QToolButton_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QToolButton*>(ptr)->QToolButton::sizeHint()).width(), static_cast<QSize>(static_cast<QToolButton*>(ptr)->QToolButton::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}
void QToolButton_SetCheckedDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QToolButton_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QToolButton_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QToolButton*>(ptr)->QToolButton::setVisible(visible != 0);
}
void QToolButton_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QToolButton_SetWindowModifiedDefault(void* ptr, int 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));
}
int QToolButton_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QToolButton_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QToolButton*>(ptr)->focusNextPrevChild(next != 0);
}
int QToolButton_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QToolButton*>(ptr)->QToolButton::focusNextPrevChild(next != 0);
}
int QToolButton_HasHeightForWidth(void* ptr)
{
return static_cast<QToolButton*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QToolButton*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QToolButton_InputMethodQueryDefault(void* ptr, int 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));
}
int QToolButton_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QToolButton*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QToolButton_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QToolButton*>(ptr)->QToolButton::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QToolButton_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QToolButton*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QToolButton_SetHiddenDefault(void* ptr, int 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));
}
int QToolButton_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QToolButton*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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();
}
int 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 QToolTip::text().toUtf8().data();
}
class MyQTreeView: public QTreeView
{
public:
MyQTreeView(QWidget *parent) : QTreeView(parent) {};
void collapse(const QModelIndex & index) { callbackQTreeView_Collapse(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void expand(const QModelIndex & index) { callbackQTreeView_Expand(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void collapseAll() { callbackQTreeView_CollapseAll(this, this->objectName().toUtf8().data()); };
void Signal_Collapsed(const QModelIndex & index) { callbackQTreeView_Collapsed(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void columnCountChanged(int oldCount, int newCount) { callbackQTreeView_ColumnCountChanged(this, this->objectName().toUtf8().data(), oldCount, newCount); };
void columnMoved() { callbackQTreeView_ColumnMoved(this, this->objectName().toUtf8().data()); };
void columnResized(int column, int oldSize, int newSize) { callbackQTreeView_ColumnResized(this, this->objectName().toUtf8().data(), column, oldSize, newSize); };
void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQTreeView_CurrentChanged(this, this->objectName().toUtf8().data(), new QModelIndex(current), new QModelIndex(previous)); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQTreeView_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void drawBranches(QPainter * painter, const QRect & rect, const QModelIndex & index) const { callbackQTreeView_DrawBranches(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data(), painter, new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), new QModelIndex(index)); };
void drawRow(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQTreeView_DrawRow(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data(), painter, new QStyleOptionViewItem(option), new QModelIndex(index)); };
void expandAll() { callbackQTreeView_ExpandAll(this, this->objectName().toUtf8().data()); };
void expandToDepth(int depth) { callbackQTreeView_ExpandToDepth(this, this->objectName().toUtf8().data(), depth); };
void Signal_Expanded(const QModelIndex & index) { callbackQTreeView_Expanded(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void hideColumn(int column) { callbackQTreeView_HideColumn(this, this->objectName().toUtf8().data(), column); };
int horizontalOffset() const { return callbackQTreeView_HorizontalOffset(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data()); };
QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQTreeView_IndexAt(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(point).x(), static_cast<QPoint>(point).y()))); };
bool isIndexHidden(const QModelIndex & index) const { return callbackQTreeView_IsIndexHidden(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index)) != 0; };
void keyPressEvent(QKeyEvent * event) { callbackQTreeView_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyboardSearch(const QString & search) { callbackQTreeView_KeyboardSearch(this, this->objectName().toUtf8().data(), search.toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQTreeView_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQTreeView_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQTreeView_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQTreeView_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQTreeView_MoveCursor(this, this->objectName().toUtf8().data(), cursorAction, modifiers)); };
void paintEvent(QPaintEvent * event) { callbackQTreeView_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void reset() { callbackQTreeView_Reset(this, this->objectName().toUtf8().data()); };
void resizeColumnToContents(int column) { callbackQTreeView_ResizeColumnToContents(this, this->objectName().toUtf8().data(), column); };
void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQTreeView_RowsAboutToBeRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQTreeView_RowsInserted(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void rowsRemoved(const QModelIndex & parent, int start, int end) { callbackQTreeView_RowsRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void scrollContentsBy(int dx, int dy) { callbackQTreeView_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQTreeView_ScrollTo(this, this->objectName().toUtf8().data(), new QModelIndex(index), hint); };
void selectAll() { callbackQTreeView_SelectAll(this, this->objectName().toUtf8().data()); };
void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQTreeView_SelectionChanged(this, this->objectName().toUtf8().data(), new QItemSelection(selected), new QItemSelection(deselected)); };
void setModel(QAbstractItemModel * model) { callbackQTreeView_SetModel(this, this->objectName().toUtf8().data(), model); };
void setRootIndex(const QModelIndex & index) { callbackQTreeView_SetRootIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQTreeView_SetSelection(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), command); };
void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQTreeView_SetSelectionModel(this, this->objectName().toUtf8().data(), selectionModel); };
void showColumn(int column) { callbackQTreeView_ShowColumn(this, this->objectName().toUtf8().data(), column); };
int sizeHintForColumn(int column) const { return callbackQTreeView_SizeHintForColumn(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data(), column); };
void updateGeometries() { callbackQTreeView_UpdateGeometries(this, this->objectName().toUtf8().data()); };
int verticalOffset() const { return callbackQTreeView_VerticalOffset(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data()); };
bool viewportEvent(QEvent * event) { return callbackQTreeView_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQTreeView_ViewportSizeHint(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data())); };
QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQTreeView_VisualRect(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index))); };
QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQTreeView_VisualRegionForSelection(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data(), new QItemSelection(selection))); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQTreeView_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void clearSelection() { callbackQTreeView_ClearSelection(this, this->objectName().toUtf8().data()); };
void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQTreeView_CloseEditor(this, this->objectName().toUtf8().data(), editor, hint); };
void commitData(QWidget * editor) { callbackQTreeView_CommitData(this, this->objectName().toUtf8().data(), editor); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQTreeView_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQTreeView_DropEvent(this, this->objectName().toUtf8().data(), event); };
void edit(const QModelIndex & index) { callbackQTreeView_Edit(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQTreeView_Edit2(this, this->objectName().toUtf8().data(), new QModelIndex(index), trigger, event) != 0; };
void editorDestroyed(QObject * editor) { callbackQTreeView_EditorDestroyed(this, this->objectName().toUtf8().data(), editor); };
void focusInEvent(QFocusEvent * event) { callbackQTreeView_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQTreeView_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * event) { callbackQTreeView_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQTreeView_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQTreeView_InputMethodQuery(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data(), query)); };
void resizeEvent(QResizeEvent * event) { callbackQTreeView_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void scrollToBottom() { callbackQTreeView_ScrollToBottom(this, this->objectName().toUtf8().data()); };
void scrollToTop() { callbackQTreeView_ScrollToTop(this, this->objectName().toUtf8().data()); };
QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQTreeView_SelectionCommand(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index), const_cast<QEvent*>(event))); };
void setCurrentIndex(const QModelIndex & index) { callbackQTreeView_SetCurrentIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
int sizeHintForRow(int row) const { return callbackQTreeView_SizeHintForRow(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data(), row); };
void startDrag(Qt::DropActions supportedActions) { callbackQTreeView_StartDrag(this, this->objectName().toUtf8().data(), supportedActions); };
void update(const QModelIndex & index) { callbackQTreeView_Update(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQTreeView_ViewOptions(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data())); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQTreeView_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTreeView_MinimumSizeHint(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data())); };
void setupViewport(QWidget * viewport) { callbackQTreeView_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQTreeView_SizeHint(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data())); };
void wheelEvent(QWheelEvent * e) { callbackQTreeView_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void changeEvent(QEvent * ev) { callbackQTreeView_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQTreeView_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQTreeView_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQTreeView_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQTreeView_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQTreeView_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQTreeView_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQTreeView_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQTreeView_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQTreeView_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQTreeView_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQTreeView_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQTreeView_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQTreeView_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQTreeView_HasHeightForWidth(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQTreeView_HeightForWidth(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQTreeView_Hide(this, this->objectName().toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * event) { callbackQTreeView_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQTreeView_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTreeView_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQTreeView_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQTreeView_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQTreeView_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQTreeView_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQTreeView_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQTreeView_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQTreeView_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQTreeView_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQTreeView_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQTreeView_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQTreeView_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void updateMicroFocus() { callbackQTreeView_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQTreeView_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQTreeView_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQTreeView_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQTreeView_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTreeView_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTreeView_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTreeView_MetaObject(const_cast<MyQTreeView*>(this), this->objectName().toUtf8().data())); };
};
int 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)));
}
int QTreeView_ExpandsOnDoubleClick(void* ptr)
{
return static_cast<QTreeView*>(ptr)->expandsOnDoubleClick();
}
int QTreeView_Indentation(void* ptr)
{
return static_cast<QTreeView*>(ptr)->indentation();
}
int QTreeView_IsAnimated(void* ptr)
{
return static_cast<QTreeView*>(ptr)->isAnimated();
}
int QTreeView_IsExpanded(void* ptr, void* index)
{
return static_cast<QTreeView*>(ptr)->isExpanded(*static_cast<QModelIndex*>(index));
}
int QTreeView_IsHeaderHidden(void* ptr)
{
return static_cast<QTreeView*>(ptr)->isHeaderHidden();
}
int QTreeView_IsSortingEnabled(void* ptr)
{
return static_cast<QTreeView*>(ptr)->isSortingEnabled();
}
int QTreeView_ItemsExpandable(void* ptr)
{
return static_cast<QTreeView*>(ptr)->itemsExpandable();
}
void QTreeView_ResetIndentation(void* ptr)
{
static_cast<QTreeView*>(ptr)->resetIndentation();
}
int QTreeView_RootIsDecorated(void* ptr)
{
return static_cast<QTreeView*>(ptr)->rootIsDecorated();
}
void QTreeView_SetAllColumnsShowFocus(void* ptr, int enable)
{
static_cast<QTreeView*>(ptr)->setAllColumnsShowFocus(enable != 0);
}
void QTreeView_SetAnimated(void* ptr, int 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, int enable)
{
static_cast<QTreeView*>(ptr)->setExpandsOnDoubleClick(enable != 0);
}
void QTreeView_SetHeaderHidden(void* ptr, int 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, int enable)
{
static_cast<QTreeView*>(ptr)->setItemsExpandable(enable != 0);
}
void QTreeView_SetRootIsDecorated(void* ptr, int show)
{
static_cast<QTreeView*>(ptr)->setRootIsDecorated(show != 0);
}
void QTreeView_SetSortingEnabled(void* ptr, int enable)
{
static_cast<QTreeView*>(ptr)->setSortingEnabled(enable != 0);
}
void QTreeView_SetUniformRowHeights(void* ptr, int uniform)
{
static_cast<QTreeView*>(ptr)->setUniformRowHeights(uniform != 0);
}
void QTreeView_SetWordWrap(void* ptr, int on)
{
static_cast<QTreeView*>(ptr)->setWordWrap(on != 0);
}
int QTreeView_UniformRowHeights(void* ptr)
{
return static_cast<QTreeView*>(ptr)->uniformRowHeights();
}
int 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));
}
int QTreeView_IsColumnHidden(void* ptr, int column)
{
return static_cast<QTreeView*>(ptr)->isColumnHidden(column);
}
int QTreeView_IsFirstColumnSpanned(void* ptr, int row, void* parent)
{
return static_cast<QTreeView*>(ptr)->isFirstColumnSpanned(row, *static_cast<QModelIndex*>(parent));
}
int QTreeView_IsIndexHidden(void* ptr, void* index)
{
return static_cast<QTreeView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}
int QTreeView_IsIndexHiddenDefault(void* ptr, void* index)
{
return static_cast<QTreeView*>(ptr)->QTreeView::isIndexHidden(*static_cast<QModelIndex*>(index));
}
int 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, int cursorAction, int modifiers)
{
return new QModelIndex(static_cast<QTreeView*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}
void* QTreeView_MoveCursorDefault(void* ptr, int cursorAction, int 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, int hint)
{
static_cast<QTreeView*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}
void QTreeView_ScrollToDefault(void* ptr, void* index, int 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, int 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, int expanded)
{
static_cast<QTreeView*>(ptr)->setExpanded(*static_cast<QModelIndex*>(index), expanded != 0);
}
void QTreeView_SetFirstColumnSpanned(void* ptr, int row, void* parent, int 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, int hide)
{
static_cast<QTreeView*>(ptr)->setRowHidden(row, *static_cast<QModelIndex*>(parent), hide != 0);
}
void QTreeView_SetSelection(void* ptr, void* rect, int command)
{
static_cast<QTreeView*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QTreeView_SetSelectionDefault(void* ptr, void* rect, int 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, int 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();
}
int QTreeView_ViewportEvent(void* ptr, void* event)
{
return static_cast<QTreeView*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int QTreeView_ViewportEventDefault(void* ptr, void* event)
{
return static_cast<QTreeView*>(ptr)->QTreeView::viewportEvent(static_cast<QEvent*>(event));
}
void* QTreeView_ViewportSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTreeView*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QTreeView*>(ptr)->viewportSizeHint()).height());
}
void* QTreeView_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTreeView*>(ptr)->QTreeView::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QTreeView*>(ptr)->QTreeView::viewportSizeHint()).height());
}
void* QTreeView_VisualRect(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QTreeView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QTreeView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QTreeView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QTreeView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).height());
}
void* QTreeView_VisualRectDefault(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QTreeView*>(ptr)->QTreeView::visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QTreeView*>(ptr)->QTreeView::visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QTreeView*>(ptr)->QTreeView::visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QTreeView*>(ptr)->QTreeView::visualRect(*static_cast<QModelIndex*>(index))).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, int 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, int 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));
}
int QTreeView_Edit2(void* ptr, void* index, int trigger, void* event)
{
return static_cast<QTreeView*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}
int QTreeView_Edit2Default(void* ptr, void* index, int 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));
}
int QTreeView_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QTreeView*>(ptr)->focusNextPrevChild(next != 0);
}
int QTreeView_FocusNextPrevChildDefault(void* ptr, int 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, int query)
{
return new QVariant(static_cast<QTreeView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QTreeView_InputMethodQueryDefault(void* ptr, int 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();
}
int QTreeView_SelectionCommand(void* ptr, void* index, void* event)
{
return static_cast<QTreeView*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}
int 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, int supportedActions)
{
static_cast<QTreeView*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}
void QTreeView_StartDragDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QTreeView*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTreeView*>(ptr)->minimumSizeHint()).height());
}
void* QTreeView_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTreeView*>(ptr)->QTreeView::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTreeView*>(ptr)->QTreeView::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QTreeView*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QTreeView*>(ptr)->sizeHint()).height());
}
void* QTreeView_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTreeView*>(ptr)->QTreeView::sizeHint()).width(), static_cast<QSize>(static_cast<QTreeView*>(ptr)->QTreeView::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QTreeView_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QTreeView_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QTreeView*>(ptr)->QTreeView::setVisible(visible != 0);
}
void QTreeView_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QTreeView_SetWindowModifiedDefault(void* ptr, int 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));
}
int QTreeView_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QTreeView_HasHeightForWidth(void* ptr)
{
return static_cast<QTreeView*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QTreeView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTreeView*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QTreeView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTreeView*>(ptr)->QTreeView::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QTreeView_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QTreeView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QTreeView_SetHiddenDefault(void* ptr, int 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));
}
int QTreeView_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QTreeView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data()); };
void collapseItem(const QTreeWidgetItem * item) { callbackQTreeWidget_CollapseItem(this, this->objectName().toUtf8().data(), const_cast<QTreeWidgetItem*>(item)); };
void Signal_CurrentItemChanged(QTreeWidgetItem * current, QTreeWidgetItem * previous) { callbackQTreeWidget_CurrentItemChanged(this, this->objectName().toUtf8().data(), current, previous); };
void dropEvent(QDropEvent * event) { callbackQTreeWidget_DropEvent(this, this->objectName().toUtf8().data(), event); };
bool dropMimeData(QTreeWidgetItem * parent, int index, const QMimeData * data, Qt::DropAction action) { return callbackQTreeWidget_DropMimeData(this, this->objectName().toUtf8().data(), parent, index, const_cast<QMimeData*>(data), action) != 0; };
void expandItem(const QTreeWidgetItem * item) { callbackQTreeWidget_ExpandItem(this, this->objectName().toUtf8().data(), const_cast<QTreeWidgetItem*>(item)); };
void Signal_ItemActivated(QTreeWidgetItem * item, int column) { callbackQTreeWidget_ItemActivated(this, this->objectName().toUtf8().data(), item, column); };
void Signal_ItemChanged(QTreeWidgetItem * item, int column) { callbackQTreeWidget_ItemChanged(this, this->objectName().toUtf8().data(), item, column); };
void Signal_ItemClicked(QTreeWidgetItem * item, int column) { callbackQTreeWidget_ItemClicked(this, this->objectName().toUtf8().data(), item, column); };
void Signal_ItemCollapsed(QTreeWidgetItem * item) { callbackQTreeWidget_ItemCollapsed(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemDoubleClicked(QTreeWidgetItem * item, int column) { callbackQTreeWidget_ItemDoubleClicked(this, this->objectName().toUtf8().data(), item, column); };
void Signal_ItemEntered(QTreeWidgetItem * item, int column) { callbackQTreeWidget_ItemEntered(this, this->objectName().toUtf8().data(), item, column); };
void Signal_ItemExpanded(QTreeWidgetItem * item) { callbackQTreeWidget_ItemExpanded(this, this->objectName().toUtf8().data(), item); };
void Signal_ItemPressed(QTreeWidgetItem * item, int column) { callbackQTreeWidget_ItemPressed(this, this->objectName().toUtf8().data(), item, column); };
void Signal_ItemSelectionChanged() { callbackQTreeWidget_ItemSelectionChanged(this, this->objectName().toUtf8().data()); };
QStringList mimeTypes() const { return QString(callbackQTreeWidget_MimeTypes(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data())).split("|", QString::SkipEmptyParts); };
void scrollToItem(const QTreeWidgetItem * item, QAbstractItemView::ScrollHint hint) { callbackQTreeWidget_ScrollToItem(this, this->objectName().toUtf8().data(), const_cast<QTreeWidgetItem*>(item), hint); };
void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQTreeWidget_SetSelectionModel(this, this->objectName().toUtf8().data(), selectionModel); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQTreeWidget_SupportedDropActions(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data())); };
void collapse(const QModelIndex & index) { callbackQTreeWidget_Collapse(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void expand(const QModelIndex & index) { callbackQTreeWidget_Expand(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void collapseAll() { callbackQTreeWidget_CollapseAll(this, this->objectName().toUtf8().data()); };
void columnCountChanged(int oldCount, int newCount) { callbackQTreeWidget_ColumnCountChanged(this, this->objectName().toUtf8().data(), oldCount, newCount); };
void columnMoved() { callbackQTreeWidget_ColumnMoved(this, this->objectName().toUtf8().data()); };
void columnResized(int column, int oldSize, int newSize) { callbackQTreeWidget_ColumnResized(this, this->objectName().toUtf8().data(), column, oldSize, newSize); };
void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQTreeWidget_CurrentChanged(this, this->objectName().toUtf8().data(), new QModelIndex(current), new QModelIndex(previous)); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQTreeWidget_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void drawBranches(QPainter * painter, const QRect & rect, const QModelIndex & index) const { callbackQTreeWidget_DrawBranches(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data(), painter, new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), new QModelIndex(index)); };
void drawRow(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const { callbackQTreeWidget_DrawRow(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data(), painter, new QStyleOptionViewItem(option), new QModelIndex(index)); };
void expandAll() { callbackQTreeWidget_ExpandAll(this, this->objectName().toUtf8().data()); };
void expandToDepth(int depth) { callbackQTreeWidget_ExpandToDepth(this, this->objectName().toUtf8().data(), depth); };
void hideColumn(int column) { callbackQTreeWidget_HideColumn(this, this->objectName().toUtf8().data(), column); };
int horizontalOffset() const { return callbackQTreeWidget_HorizontalOffset(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data()); };
QModelIndex indexAt(const QPoint & point) const { return *static_cast<QModelIndex*>(callbackQTreeWidget_IndexAt(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(point).x(), static_cast<QPoint>(point).y()))); };
bool isIndexHidden(const QModelIndex & index) const { return callbackQTreeWidget_IsIndexHidden(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data(), new QModelIndex(index)) != 0; };
void keyPressEvent(QKeyEvent * event) { callbackQTreeWidget_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyboardSearch(const QString & search) { callbackQTreeWidget_KeyboardSearch(this, this->objectName().toUtf8().data(), search.toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQTreeWidget_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQTreeWidget_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQTreeWidget_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQTreeWidget_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQTreeWidget_MoveCursor(this, this->objectName().toUtf8().data(), cursorAction, modifiers)); };
void paintEvent(QPaintEvent * event) { callbackQTreeWidget_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void reset() { callbackQTreeWidget_Reset(this, this->objectName().toUtf8().data()); };
void resizeColumnToContents(int column) { callbackQTreeWidget_ResizeColumnToContents(this, this->objectName().toUtf8().data(), column); };
void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQTreeWidget_RowsAboutToBeRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQTreeWidget_RowsInserted(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void rowsRemoved(const QModelIndex & parent, int start, int end) { callbackQTreeWidget_RowsRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void scrollContentsBy(int dx, int dy) { callbackQTreeWidget_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQTreeWidget_ScrollTo(this, this->objectName().toUtf8().data(), new QModelIndex(index), hint); };
void selectAll() { callbackQTreeWidget_SelectAll(this, this->objectName().toUtf8().data()); };
void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQTreeWidget_SelectionChanged(this, this->objectName().toUtf8().data(), new QItemSelection(selected), new QItemSelection(deselected)); };
void setModel(QAbstractItemModel * model) { callbackQTreeWidget_SetModel(this, this->objectName().toUtf8().data(), model); };
void setRootIndex(const QModelIndex & index) { callbackQTreeWidget_SetRootIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQTreeWidget_SetSelection(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), command); };
void showColumn(int column) { callbackQTreeWidget_ShowColumn(this, this->objectName().toUtf8().data(), column); };
int sizeHintForColumn(int column) const { return callbackQTreeWidget_SizeHintForColumn(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data(), column); };
void updateGeometries() { callbackQTreeWidget_UpdateGeometries(this, this->objectName().toUtf8().data()); };
int verticalOffset() const { return callbackQTreeWidget_VerticalOffset(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data()); };
bool viewportEvent(QEvent * event) { return callbackQTreeWidget_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQTreeWidget_ViewportSizeHint(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data())); };
QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQTreeWidget_VisualRect(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data(), new QModelIndex(index))); };
QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQTreeWidget_VisualRegionForSelection(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data(), new QItemSelection(selection))); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQTreeWidget_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void clearSelection() { callbackQTreeWidget_ClearSelection(this, this->objectName().toUtf8().data()); };
void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQTreeWidget_CloseEditor(this, this->objectName().toUtf8().data(), editor, hint); };
void commitData(QWidget * editor) { callbackQTreeWidget_CommitData(this, this->objectName().toUtf8().data(), editor); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQTreeWidget_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void edit(const QModelIndex & index) { callbackQTreeWidget_Edit(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQTreeWidget_Edit2(this, this->objectName().toUtf8().data(), new QModelIndex(index), trigger, event) != 0; };
void editorDestroyed(QObject * editor) { callbackQTreeWidget_EditorDestroyed(this, this->objectName().toUtf8().data(), editor); };
void focusInEvent(QFocusEvent * event) { callbackQTreeWidget_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQTreeWidget_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * event) { callbackQTreeWidget_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQTreeWidget_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQTreeWidget_InputMethodQuery(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data(), query)); };
void resizeEvent(QResizeEvent * event) { callbackQTreeWidget_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void scrollToBottom() { callbackQTreeWidget_ScrollToBottom(this, this->objectName().toUtf8().data()); };
void scrollToTop() { callbackQTreeWidget_ScrollToTop(this, this->objectName().toUtf8().data()); };
QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQTreeWidget_SelectionCommand(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data(), new QModelIndex(index), const_cast<QEvent*>(event))); };
void setCurrentIndex(const QModelIndex & index) { callbackQTreeWidget_SetCurrentIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
int sizeHintForRow(int row) const { return callbackQTreeWidget_SizeHintForRow(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data(), row); };
void startDrag(Qt::DropActions supportedActions) { callbackQTreeWidget_StartDrag(this, this->objectName().toUtf8().data(), supportedActions); };
void update(const QModelIndex & index) { callbackQTreeWidget_Update(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQTreeWidget_ViewOptions(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data())); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQTreeWidget_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQTreeWidget_MinimumSizeHint(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data())); };
void setupViewport(QWidget * viewport) { callbackQTreeWidget_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQTreeWidget_SizeHint(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data())); };
void wheelEvent(QWheelEvent * e) { callbackQTreeWidget_WheelEvent(this, this->objectName().toUtf8().data(), e); };
void changeEvent(QEvent * ev) { callbackQTreeWidget_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQTreeWidget_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQTreeWidget_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQTreeWidget_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQTreeWidget_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQTreeWidget_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQTreeWidget_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQTreeWidget_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQTreeWidget_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQTreeWidget_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQTreeWidget_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQTreeWidget_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQTreeWidget_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQTreeWidget_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQTreeWidget_HasHeightForWidth(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQTreeWidget_HeightForWidth(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQTreeWidget_Hide(this, this->objectName().toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * event) { callbackQTreeWidget_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQTreeWidget_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQTreeWidget_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQTreeWidget_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQTreeWidget_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQTreeWidget_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQTreeWidget_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQTreeWidget_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQTreeWidget_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQTreeWidget_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQTreeWidget_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQTreeWidget_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQTreeWidget_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQTreeWidget_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void updateMicroFocus() { callbackQTreeWidget_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQTreeWidget_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQTreeWidget_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQTreeWidget_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQTreeWidget_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTreeWidget_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTreeWidget_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTreeWidget_MetaObject(const_cast<MyQTreeWidget*>(this), this->objectName().toUtf8().data())); };
};
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));
}
int QTreeWidget_DropMimeData(void* ptr, void* parent, int index, void* data, int action)
{
return static_cast<QTreeWidget*>(ptr)->dropMimeData(static_cast<QTreeWidgetItem*>(parent), index, static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action));
}
int QTreeWidget_DropMimeDataDefault(void* ptr, void* parent, int index, void* data, int 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);
}
int 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();
}
int 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 static_cast<QTreeWidget*>(ptr)->mimeTypes().join("|").toUtf8().data();
}
char* QTreeWidget_MimeTypesDefault(void* ptr)
{
return static_cast<QTreeWidget*>(ptr)->QTreeWidget::mimeTypes().join("|").toUtf8().data();
}
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, int 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, int command)
{
static_cast<QTreeWidget*>(ptr)->setCurrentItem(static_cast<QTreeWidgetItem*>(item), column, static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QTreeWidget_SetFirstItemColumnSpanned(void* ptr, void* item, int 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, int order)
{
static_cast<QTreeWidget*>(ptr)->sortItems(column, static_cast<Qt::SortOrder>(order));
}
int QTreeWidget_SupportedDropActions(void* ptr)
{
return static_cast<QTreeWidget*>(ptr)->supportedDropActions();
}
int 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 new QRect(static_cast<QRect>(static_cast<QTreeWidget*>(ptr)->visualItemRect(static_cast<QTreeWidgetItem*>(item))).x(), static_cast<QRect>(static_cast<QTreeWidget*>(ptr)->visualItemRect(static_cast<QTreeWidgetItem*>(item))).y(), static_cast<QRect>(static_cast<QTreeWidget*>(ptr)->visualItemRect(static_cast<QTreeWidgetItem*>(item))).width(), static_cast<QRect>(static_cast<QTreeWidget*>(ptr)->visualItemRect(static_cast<QTreeWidgetItem*>(item))).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)));
}
int QTreeWidget_IsIndexHidden(void* ptr, void* index)
{
return static_cast<QTreeWidget*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}
int 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, int cursorAction, int modifiers)
{
return new QModelIndex(static_cast<QTreeWidget*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}
void* QTreeWidget_MoveCursorDefault(void* ptr, int cursorAction, int 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, int hint)
{
static_cast<QTreeWidget*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}
void QTreeWidget_ScrollToDefault(void* ptr, void* index, int 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, int command)
{
static_cast<QTreeWidget*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QTreeWidget_SetSelectionDefault(void* ptr, void* rect, int 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();
}
int QTreeWidget_ViewportEvent(void* ptr, void* event)
{
return static_cast<QTreeWidget*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int QTreeWidget_ViewportEventDefault(void* ptr, void* event)
{
return static_cast<QTreeWidget*>(ptr)->QTreeWidget::viewportEvent(static_cast<QEvent*>(event));
}
void* QTreeWidget_ViewportSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTreeWidget*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QTreeWidget*>(ptr)->viewportSizeHint()).height());
}
void* QTreeWidget_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::viewportSizeHint()).height());
}
void* QTreeWidget_VisualRect(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QTreeWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QTreeWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QTreeWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QTreeWidget*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).height());
}
void* QTreeWidget_VisualRectDefault(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::visualRect(*static_cast<QModelIndex*>(index))).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, int 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, int 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));
}
int QTreeWidget_Edit2(void* ptr, void* index, int trigger, void* event)
{
return static_cast<QTreeWidget*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}
int QTreeWidget_Edit2Default(void* ptr, void* index, int 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));
}
int QTreeWidget_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QTreeWidget*>(ptr)->focusNextPrevChild(next != 0);
}
int QTreeWidget_FocusNextPrevChildDefault(void* ptr, int 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, int query)
{
return new QVariant(static_cast<QTreeWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QTreeWidget_InputMethodQueryDefault(void* ptr, int 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();
}
int QTreeWidget_SelectionCommand(void* ptr, void* index, void* event)
{
return static_cast<QTreeWidget*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}
int 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, int supportedActions)
{
static_cast<QTreeWidget*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}
void QTreeWidget_StartDragDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QTreeWidget*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTreeWidget*>(ptr)->minimumSizeHint()).height());
}
void* QTreeWidget_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QTreeWidget*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QTreeWidget*>(ptr)->sizeHint()).height());
}
void* QTreeWidget_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::sizeHint()).width(), static_cast<QSize>(static_cast<QTreeWidget*>(ptr)->QTreeWidget::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QTreeWidget_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QTreeWidget_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QTreeWidget*>(ptr)->QTreeWidget::setVisible(visible != 0);
}
void QTreeWidget_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QTreeWidget_SetWindowModifiedDefault(void* ptr, int 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));
}
int QTreeWidget_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QTreeWidget_HasHeightForWidth(void* ptr)
{
return static_cast<QTreeWidget*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QTreeWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTreeWidget*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QTreeWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QTreeWidget*>(ptr)->QTreeWidget::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QTreeWidget_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QTreeWidget*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QTreeWidget_SetHiddenDefault(void* ptr, int 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));
}
int QTreeWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QTreeWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
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), this->objectNameAbs().toUtf8().data(), column, role)); };
QTreeWidgetItem * clone() const { return static_cast<QTreeWidgetItem*>(callbackQTreeWidgetItem_Clone(const_cast<MyQTreeWidgetItem*>(this), this->objectNameAbs().toUtf8().data())); };
void setData(int column, int role, const QVariant & value) { callbackQTreeWidgetItem_SetData(this, this->objectNameAbs().toUtf8().data(), column, role, new QVariant(value)); };
};
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);
}
int QTreeWidgetItem_Flags(void* ptr)
{
return static_cast<QTreeWidgetItem*>(ptr)->flags();
}
void QTreeWidgetItem_SetFlags(void* ptr, int 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));
}
int 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();
}
int 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));
}
int QTreeWidgetItem_IsDisabled(void* ptr)
{
return static_cast<QTreeWidgetItem*>(ptr)->isDisabled();
}
int QTreeWidgetItem_IsExpanded(void* ptr)
{
return static_cast<QTreeWidgetItem*>(ptr)->isExpanded();
}
int QTreeWidgetItem_IsFirstColumnSpanned(void* ptr)
{
return static_cast<QTreeWidgetItem*>(ptr)->isFirstColumnSpanned();
}
int QTreeWidgetItem_IsHidden(void* ptr)
{
return static_cast<QTreeWidgetItem*>(ptr)->isHidden();
}
int 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, int state)
{
static_cast<QTreeWidgetItem*>(ptr)->setCheckState(column, static_cast<Qt::CheckState>(state));
}
void QTreeWidgetItem_SetChildIndicatorPolicy(void* ptr, int 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, int disabled)
{
static_cast<QTreeWidgetItem*>(ptr)->setDisabled(disabled != 0);
}
void QTreeWidgetItem_SetExpanded(void* ptr, int expand)
{
static_cast<QTreeWidgetItem*>(ptr)->setExpanded(expand != 0);
}
void QTreeWidgetItem_SetFirstColumnSpanned(void* ptr, int 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, int 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, int 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 new QSize(static_cast<QSize>(static_cast<QTreeWidgetItem*>(ptr)->sizeHint(column)).width(), static_cast<QSize>(static_cast<QTreeWidgetItem*>(ptr)->sizeHint(column)).height());
}
void QTreeWidgetItem_SortChildren(void* ptr, int column, int order)
{
static_cast<QTreeWidgetItem*>(ptr)->sortChildren(column, static_cast<Qt::SortOrder>(order));
}
char* QTreeWidgetItem_StatusTip(void* ptr, int column)
{
return static_cast<QTreeWidgetItem*>(ptr)->statusTip(column).toUtf8().data();
}
void* QTreeWidgetItem_TakeChild(void* ptr, int index)
{
return static_cast<QTreeWidgetItem*>(ptr)->takeChild(index);
}
char* QTreeWidgetItem_Text(void* ptr, int column)
{
return static_cast<QTreeWidgetItem*>(ptr)->text(column).toUtf8().data();
}
int QTreeWidgetItem_TextAlignment(void* ptr, int column)
{
return static_cast<QTreeWidgetItem*>(ptr)->textAlignment(column);
}
char* QTreeWidgetItem_ToolTip(void* ptr, int column)
{
return static_cast<QTreeWidgetItem*>(ptr)->toolTip(column).toUtf8().data();
}
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 static_cast<QTreeWidgetItem*>(ptr)->whatsThis(column).toUtf8().data();
}
void QTreeWidgetItem_DestroyQTreeWidgetItem(void* ptr)
{
static_cast<QTreeWidgetItem*>(ptr)->~QTreeWidgetItem();
}
char* QTreeWidgetItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQTreeWidgetItem*>(static_cast<QTreeWidgetItem*>(ptr))) {
return static_cast<MyQTreeWidgetItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QTreeWidgetItem_BASE").toUtf8().data();
}
void QTreeWidgetItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQTreeWidgetItem*>(static_cast<QTreeWidgetItem*>(ptr))) {
static_cast<MyQTreeWidgetItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
class MyQUndoCommand: public QUndoCommand
{
public:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQUndoCommand(QUndoCommand *parent) : QUndoCommand(parent) {};
MyQUndoCommand(const QString &text, QUndoCommand *parent) : QUndoCommand(text, parent) {};
int id() const { return callbackQUndoCommand_Id(const_cast<MyQUndoCommand*>(this), this->objectNameAbs().toUtf8().data()); };
bool mergeWith(const QUndoCommand * command) { return callbackQUndoCommand_MergeWith(this, this->objectNameAbs().toUtf8().data(), const_cast<QUndoCommand*>(command)) != 0; };
void redo() { callbackQUndoCommand_Redo(this, this->objectNameAbs().toUtf8().data()); };
void undo() { callbackQUndoCommand_Undo(this, this->objectNameAbs().toUtf8().data()); };
};
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 static_cast<QUndoCommand*>(ptr)->actionText().toUtf8().data();
}
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();
}
int QUndoCommand_MergeWith(void* ptr, void* command)
{
return static_cast<QUndoCommand*>(ptr)->mergeWith(static_cast<QUndoCommand*>(command));
}
int 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 static_cast<QUndoCommand*>(ptr)->text().toUtf8().data();
}
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();
}
char* QUndoCommand_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQUndoCommand*>(static_cast<QUndoCommand*>(ptr))) {
return static_cast<MyQUndoCommand*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QUndoCommand_BASE").toUtf8().data();
}
void QUndoCommand_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQUndoCommand*>(static_cast<QUndoCommand*>(ptr))) {
static_cast<MyQUndoCommand*>(ptr)->setObjectNameAbs(QString(name));
}
}
class MyQUndoGroup: public QUndoGroup
{
public:
MyQUndoGroup(QObject *parent) : QUndoGroup(parent) {};
void Signal_ActiveStackChanged(QUndoStack * stack) { callbackQUndoGroup_ActiveStackChanged(this, this->objectName().toUtf8().data(), stack); };
void Signal_CanRedoChanged(bool canRedo) { callbackQUndoGroup_CanRedoChanged(this, this->objectName().toUtf8().data(), canRedo); };
void Signal_CanUndoChanged(bool canUndo) { callbackQUndoGroup_CanUndoChanged(this, this->objectName().toUtf8().data(), canUndo); };
void Signal_CleanChanged(bool clean) { callbackQUndoGroup_CleanChanged(this, this->objectName().toUtf8().data(), clean); };
void Signal_IndexChanged(int idx) { callbackQUndoGroup_IndexChanged(this, this->objectName().toUtf8().data(), idx); };
void redo() { callbackQUndoGroup_Redo(this, this->objectName().toUtf8().data()); };
void Signal_RedoTextChanged(const QString & redoText) { callbackQUndoGroup_RedoTextChanged(this, this->objectName().toUtf8().data(), redoText.toUtf8().data()); };
void setActiveStack(QUndoStack * stack) { callbackQUndoGroup_SetActiveStack(this, this->objectName().toUtf8().data(), stack); };
void undo() { callbackQUndoGroup_Undo(this, this->objectName().toUtf8().data()); };
void Signal_UndoTextChanged(const QString & undoText) { callbackQUndoGroup_UndoTextChanged(this, this->objectName().toUtf8().data(), undoText.toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQUndoGroup_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQUndoGroup_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQUndoGroup_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQUndoGroup_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQUndoGroup_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQUndoGroup_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQUndoGroup_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQUndoGroup_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQUndoGroup_MetaObject(const_cast<MyQUndoGroup*>(this), this->objectName().toUtf8().data())); };
};
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));
}
int 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, int canRedo)
{
static_cast<QUndoGroup*>(ptr)->canRedoChanged(canRedo != 0);
}
int 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, int 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, int 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);
}
int 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 static_cast<QUndoGroup*>(ptr)->redoText().toUtf8().data();
}
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 static_cast<QUndoGroup*>(ptr)->undoText().toUtf8().data();
}
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));
}
int QUndoGroup_Event(void* ptr, void* e)
{
return static_cast<QUndoGroup*>(ptr)->event(static_cast<QEvent*>(e));
}
int QUndoGroup_EventDefault(void* ptr, void* e)
{
return static_cast<QUndoGroup*>(ptr)->QUndoGroup::event(static_cast<QEvent*>(e));
}
int QUndoGroup_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QUndoGroup*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), active); };
void Signal_CanRedoChanged(bool canRedo) { callbackQUndoStack_CanRedoChanged(this, this->objectName().toUtf8().data(), canRedo); };
void Signal_CanUndoChanged(bool canUndo) { callbackQUndoStack_CanUndoChanged(this, this->objectName().toUtf8().data(), canUndo); };
void Signal_CleanChanged(bool clean) { callbackQUndoStack_CleanChanged(this, this->objectName().toUtf8().data(), clean); };
void Signal_IndexChanged(int idx) { callbackQUndoStack_IndexChanged(this, this->objectName().toUtf8().data(), idx); };
void redo() { callbackQUndoStack_Redo(this, this->objectName().toUtf8().data()); };
void Signal_RedoTextChanged(const QString & redoText) { callbackQUndoStack_RedoTextChanged(this, this->objectName().toUtf8().data(), redoText.toUtf8().data()); };
void setClean() { callbackQUndoStack_SetClean(this, this->objectName().toUtf8().data()); };
void setIndex(int idx) { callbackQUndoStack_SetIndex(this, this->objectName().toUtf8().data(), idx); };
void undo() { callbackQUndoStack_Undo(this, this->objectName().toUtf8().data()); };
void Signal_UndoTextChanged(const QString & undoText) { callbackQUndoStack_UndoTextChanged(this, this->objectName().toUtf8().data(), undoText.toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQUndoStack_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQUndoStack_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQUndoStack_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQUndoStack_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQUndoStack_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQUndoStack_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool event(QEvent * e) { return callbackQUndoStack_Event(this, this->objectName().toUtf8().data(), e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQUndoStack_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQUndoStack_MetaObject(const_cast<MyQUndoStack*>(this), this->objectName().toUtf8().data())); };
};
int QUndoStack_IsActive(void* ptr)
{
return static_cast<QUndoStack*>(ptr)->isActive();
}
void QUndoStack_SetActive(void* ptr, int 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));
}
int 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, int canRedo)
{
static_cast<QUndoStack*>(ptr)->canRedoChanged(canRedo != 0);
}
int 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, int 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, int 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);
}
int 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 static_cast<QUndoStack*>(ptr)->redoText().toUtf8().data();
}
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 static_cast<QUndoStack*>(ptr)->text(idx).toUtf8().data();
}
void QUndoStack_Undo(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QUndoStack*>(ptr), "undo");
}
char* QUndoStack_UndoText(void* ptr)
{
return static_cast<QUndoStack*>(ptr)->undoText().toUtf8().data();
}
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));
}
int QUndoStack_Event(void* ptr, void* e)
{
return static_cast<QUndoStack*>(ptr)->event(static_cast<QEvent*>(e));
}
int QUndoStack_EventDefault(void* ptr, void* e)
{
return static_cast<QUndoStack*>(ptr)->QUndoStack::event(static_cast<QEvent*>(e));
}
int QUndoStack_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QUndoStack*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), group); };
void setStack(QUndoStack * stack) { callbackQUndoView_SetStack(this, this->objectName().toUtf8().data(), stack); };
void currentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQUndoView_CurrentChanged(this, this->objectName().toUtf8().data(), new QModelIndex(current), new QModelIndex(previous)); };
void dragLeaveEvent(QDragLeaveEvent * e) { callbackQUndoView_DragLeaveEvent(this, this->objectName().toUtf8().data(), e); };
void dragMoveEvent(QDragMoveEvent * e) { callbackQUndoView_DragMoveEvent(this, this->objectName().toUtf8().data(), e); };
void dropEvent(QDropEvent * e) { callbackQUndoView_DropEvent(this, this->objectName().toUtf8().data(), e); };
int horizontalOffset() const { return callbackQUndoView_HorizontalOffset(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data()); };
QModelIndex indexAt(const QPoint & p) const { return *static_cast<QModelIndex*>(callbackQUndoView_IndexAt(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(p).x(), static_cast<QPoint>(p).y()))); };
bool isIndexHidden(const QModelIndex & index) const { return callbackQUndoView_IsIndexHidden(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index)) != 0; };
void mouseMoveEvent(QMouseEvent * e) { callbackQUndoView_MouseMoveEvent(this, this->objectName().toUtf8().data(), e); };
void mouseReleaseEvent(QMouseEvent * e) { callbackQUndoView_MouseReleaseEvent(this, this->objectName().toUtf8().data(), e); };
QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { return *static_cast<QModelIndex*>(callbackQUndoView_MoveCursor(this, this->objectName().toUtf8().data(), cursorAction, modifiers)); };
void paintEvent(QPaintEvent * e) { callbackQUndoView_PaintEvent(this, this->objectName().toUtf8().data(), e); };
void resizeEvent(QResizeEvent * e) { callbackQUndoView_ResizeEvent(this, this->objectName().toUtf8().data(), e); };
void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { callbackQUndoView_RowsAboutToBeRemoved(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void rowsInserted(const QModelIndex & parent, int start, int end) { callbackQUndoView_RowsInserted(this, this->objectName().toUtf8().data(), new QModelIndex(parent), start, end); };
void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { callbackQUndoView_ScrollTo(this, this->objectName().toUtf8().data(), new QModelIndex(index), hint); };
void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQUndoView_SelectionChanged(this, this->objectName().toUtf8().data(), new QItemSelection(selected), new QItemSelection(deselected)); };
void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { callbackQUndoView_SetSelection(this, this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), command); };
void startDrag(Qt::DropActions supportedActions) { callbackQUndoView_StartDrag(this, this->objectName().toUtf8().data(), supportedActions); };
void updateGeometries() { callbackQUndoView_UpdateGeometries(this, this->objectName().toUtf8().data()); };
int verticalOffset() const { return callbackQUndoView_VerticalOffset(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data()); };
QStyleOptionViewItem viewOptions() const { return *static_cast<QStyleOptionViewItem*>(callbackQUndoView_ViewOptions(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data())); };
QSize viewportSizeHint() const { return *static_cast<QSize*>(callbackQUndoView_ViewportSizeHint(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data())); };
QRect visualRect(const QModelIndex & index) const { return *static_cast<QRect*>(callbackQUndoView_VisualRect(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index))); };
QRegion visualRegionForSelection(const QItemSelection & selection) const { return *static_cast<QRegion*>(callbackQUndoView_VisualRegionForSelection(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data(), new QItemSelection(selection))); };
void wheelEvent(QWheelEvent * e) { callbackQUndoView_WheelEvent(this, this->objectName().toUtf8().data(), e); };
bool viewportEvent(QEvent * event) { return callbackQUndoView_ViewportEvent(this, this->objectName().toUtf8().data(), event) != 0; };
void clearSelection() { callbackQUndoView_ClearSelection(this, this->objectName().toUtf8().data()); };
void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { callbackQUndoView_CloseEditor(this, this->objectName().toUtf8().data(), editor, hint); };
void commitData(QWidget * editor) { callbackQUndoView_CommitData(this, this->objectName().toUtf8().data(), editor); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQUndoView_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void edit(const QModelIndex & index) { callbackQUndoView_Edit(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
bool edit(const QModelIndex & index, QAbstractItemView::EditTrigger trigger, QEvent * event) { return callbackQUndoView_Edit2(this, this->objectName().toUtf8().data(), new QModelIndex(index), trigger, event) != 0; };
void editorDestroyed(QObject * editor) { callbackQUndoView_EditorDestroyed(this, this->objectName().toUtf8().data(), editor); };
void focusInEvent(QFocusEvent * event) { callbackQUndoView_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQUndoView_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
void focusOutEvent(QFocusEvent * event) { callbackQUndoView_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQUndoView_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQUndoView_InputMethodQuery(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQUndoView_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyboardSearch(const QString & search) { callbackQUndoView_KeyboardSearch(this, this->objectName().toUtf8().data(), search.toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQUndoView_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQUndoView_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void reset() { callbackQUndoView_Reset(this, this->objectName().toUtf8().data()); };
void scrollToBottom() { callbackQUndoView_ScrollToBottom(this, this->objectName().toUtf8().data()); };
void scrollToTop() { callbackQUndoView_ScrollToTop(this, this->objectName().toUtf8().data()); };
void selectAll() { callbackQUndoView_SelectAll(this, this->objectName().toUtf8().data()); };
QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex & index, const QEvent * event) const { return static_cast<QItemSelectionModel::SelectionFlag>(callbackQUndoView_SelectionCommand(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data(), new QModelIndex(index), const_cast<QEvent*>(event))); };
void setCurrentIndex(const QModelIndex & index) { callbackQUndoView_SetCurrentIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setModel(QAbstractItemModel * model) { callbackQUndoView_SetModel(this, this->objectName().toUtf8().data(), model); };
void setRootIndex(const QModelIndex & index) { callbackQUndoView_SetRootIndex(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void setSelectionModel(QItemSelectionModel * selectionModel) { callbackQUndoView_SetSelectionModel(this, this->objectName().toUtf8().data(), selectionModel); };
int sizeHintForColumn(int column) const { return callbackQUndoView_SizeHintForColumn(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data(), column); };
int sizeHintForRow(int row) const { return callbackQUndoView_SizeHintForRow(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data(), row); };
void update(const QModelIndex & index) { callbackQUndoView_Update(this, this->objectName().toUtf8().data(), new QModelIndex(index)); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQUndoView_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQUndoView_MinimumSizeHint(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data())); };
void scrollContentsBy(int dx, int dy) { callbackQUndoView_ScrollContentsBy(this, this->objectName().toUtf8().data(), dx, dy); };
void setupViewport(QWidget * viewport) { callbackQUndoView_SetupViewport(this, this->objectName().toUtf8().data(), viewport); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQUndoView_SizeHint(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * ev) { callbackQUndoView_ChangeEvent(this, this->objectName().toUtf8().data(), ev); };
void actionEvent(QActionEvent * event) { callbackQUndoView_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQUndoView_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQUndoView_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQUndoView_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQUndoView_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQUndoView_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQUndoView_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQUndoView_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQUndoView_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQUndoView_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQUndoView_ShowEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQUndoView_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQUndoView_CloseEvent(this, this->objectName().toUtf8().data(), event); };
bool hasHeightForWidth() const { return callbackQUndoView_HasHeightForWidth(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQUndoView_HeightForWidth(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQUndoView_Hide(this, this->objectName().toUtf8().data()); };
void keyReleaseEvent(QKeyEvent * event) { callbackQUndoView_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQUndoView_Lower(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQUndoView_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQUndoView_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQUndoView_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQUndoView_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQUndoView_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQUndoView_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQUndoView_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQUndoView_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQUndoView_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQUndoView_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQUndoView_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQUndoView_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void updateMicroFocus() { callbackQUndoView_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void childEvent(QChildEvent * event) { callbackQUndoView_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQUndoView_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQUndoView_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQUndoView_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQUndoView_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQUndoView_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQUndoView_MetaObject(const_cast<MyQUndoView*>(this), this->objectName().toUtf8().data())); };
};
void* QUndoView_CleanIcon(void* ptr)
{
return new QIcon(static_cast<QUndoView*>(ptr)->cleanIcon());
}
char* QUndoView_EmptyLabel(void* ptr)
{
return static_cast<QUndoView*>(ptr)->emptyLabel().toUtf8().data();
}
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)));
}
int QUndoView_IsIndexHidden(void* ptr, void* index)
{
return static_cast<QUndoView*>(ptr)->isIndexHidden(*static_cast<QModelIndex*>(index));
}
int 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, int cursorAction, int modifiers)
{
return new QModelIndex(static_cast<QUndoView*>(ptr)->moveCursor(static_cast<QAbstractItemView::CursorAction>(cursorAction), static_cast<Qt::KeyboardModifier>(modifiers)));
}
void* QUndoView_MoveCursorDefault(void* ptr, int cursorAction, int 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, int hint)
{
static_cast<QUndoView*>(ptr)->scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
}
void QUndoView_ScrollToDefault(void* ptr, void* index, int 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, int command)
{
static_cast<QUndoView*>(ptr)->setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QUndoView_SetSelectionDefault(void* ptr, void* rect, int command)
{
static_cast<QUndoView*>(ptr)->QUndoView::setSelection(*static_cast<QRect*>(rect), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QUndoView_StartDrag(void* ptr, int supportedActions)
{
static_cast<QUndoView*>(ptr)->startDrag(static_cast<Qt::DropAction>(supportedActions));
}
void QUndoView_StartDragDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QUndoView*>(ptr)->viewportSizeHint()).width(), static_cast<QSize>(static_cast<QUndoView*>(ptr)->viewportSizeHint()).height());
}
void* QUndoView_ViewportSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QUndoView*>(ptr)->QUndoView::viewportSizeHint()).width(), static_cast<QSize>(static_cast<QUndoView*>(ptr)->QUndoView::viewportSizeHint()).height());
}
void* QUndoView_VisualRect(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QUndoView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QUndoView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QUndoView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QUndoView*>(ptr)->visualRect(*static_cast<QModelIndex*>(index))).height());
}
void* QUndoView_VisualRectDefault(void* ptr, void* index)
{
return new QRect(static_cast<QRect>(static_cast<QUndoView*>(ptr)->QUndoView::visualRect(*static_cast<QModelIndex*>(index))).x(), static_cast<QRect>(static_cast<QUndoView*>(ptr)->QUndoView::visualRect(*static_cast<QModelIndex*>(index))).y(), static_cast<QRect>(static_cast<QUndoView*>(ptr)->QUndoView::visualRect(*static_cast<QModelIndex*>(index))).width(), static_cast<QRect>(static_cast<QUndoView*>(ptr)->QUndoView::visualRect(*static_cast<QModelIndex*>(index))).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));
}
int QUndoView_ViewportEvent(void* ptr, void* event)
{
return static_cast<QUndoView*>(ptr)->viewportEvent(static_cast<QEvent*>(event));
}
int 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, int 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, int 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));
}
int QUndoView_Edit2(void* ptr, void* index, int trigger, void* event)
{
return static_cast<QUndoView*>(ptr)->edit(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::EditTrigger>(trigger), static_cast<QEvent*>(event));
}
int QUndoView_Edit2Default(void* ptr, void* index, int 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));
}
int QUndoView_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QUndoView*>(ptr)->focusNextPrevChild(next != 0);
}
int QUndoView_FocusNextPrevChildDefault(void* ptr, int 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, int query)
{
return new QVariant(static_cast<QUndoView*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QUndoView_InputMethodQueryDefault(void* ptr, int 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();
}
int QUndoView_SelectionCommand(void* ptr, void* index, void* event)
{
return static_cast<QUndoView*>(ptr)->selectionCommand(*static_cast<QModelIndex*>(index), static_cast<QEvent*>(event));
}
int 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 new QSize(static_cast<QSize>(static_cast<QUndoView*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QUndoView*>(ptr)->minimumSizeHint()).height());
}
void* QUndoView_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QUndoView*>(ptr)->QUndoView::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QUndoView*>(ptr)->QUndoView::minimumSizeHint()).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 new QSize(static_cast<QSize>(static_cast<QUndoView*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QUndoView*>(ptr)->sizeHint()).height());
}
void* QUndoView_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QUndoView*>(ptr)->QUndoView::sizeHint()).width(), static_cast<QSize>(static_cast<QUndoView*>(ptr)->QUndoView::sizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QUndoView_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QUndoView_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QUndoView*>(ptr)->QUndoView::setVisible(visible != 0);
}
void QUndoView_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QUndoView_SetWindowModifiedDefault(void* ptr, int 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));
}
int QUndoView_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QUndoView_HasHeightForWidth(void* ptr)
{
return static_cast<QUndoView*>(ptr)->hasHeightForWidth();
}
int 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();
}
int QUndoView_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QUndoView*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QUndoView_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QUndoView*>(ptr)->QUndoView::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QUndoView_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QUndoView*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QUndoView_SetHiddenDefault(void* ptr, int 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));
}
int QUndoView_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QUndoView*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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();
}
int QVBoxLayout_ExpandingDirections(void* ptr)
{
return static_cast<QVBoxLayout*>(ptr)->expandingDirections();
}
int QVBoxLayout_ExpandingDirectionsDefault(void* ptr)
{
return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::expandingDirections();
}
int QVBoxLayout_HasHeightForWidth(void* ptr)
{
return static_cast<QVBoxLayout*>(ptr)->hasHeightForWidth();
}
int 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 new QSize(static_cast<QSize>(static_cast<QVBoxLayout*>(ptr)->maximumSize()).width(), static_cast<QSize>(static_cast<QVBoxLayout*>(ptr)->maximumSize()).height());
}
void* QVBoxLayout_MaximumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::maximumSize()).width(), static_cast<QSize>(static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::maximumSize()).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 new QSize(static_cast<QSize>(static_cast<QVBoxLayout*>(ptr)->minimumSize()).width(), static_cast<QSize>(static_cast<QVBoxLayout*>(ptr)->minimumSize()).height());
}
void* QVBoxLayout_MinimumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::minimumSize()).width(), static_cast<QSize>(static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::minimumSize()).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 new QSize(static_cast<QSize>(static_cast<QVBoxLayout*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QVBoxLayout*>(ptr)->sizeHint()).height());
}
void* QVBoxLayout_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::sizeHint()).width(), static_cast<QSize>(static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::sizeHint()).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);
}
int QVBoxLayout_ControlTypes(void* ptr)
{
return static_cast<QVBoxLayout*>(ptr)->controlTypes();
}
int QVBoxLayout_ControlTypesDefault(void* ptr)
{
return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::controlTypes();
}
void* QVBoxLayout_Geometry(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QVBoxLayout*>(ptr)->geometry()).x(), static_cast<QRect>(static_cast<QVBoxLayout*>(ptr)->geometry()).y(), static_cast<QRect>(static_cast<QVBoxLayout*>(ptr)->geometry()).width(), static_cast<QRect>(static_cast<QVBoxLayout*>(ptr)->geometry()).height());
}
void* QVBoxLayout_GeometryDefault(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::geometry()).x(), static_cast<QRect>(static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::geometry()).y(), static_cast<QRect>(static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::geometry()).width(), static_cast<QRect>(static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::geometry()).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));
}
int QVBoxLayout_IsEmpty(void* ptr)
{
return static_cast<QVBoxLayout*>(ptr)->isEmpty();
}
int 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));
}
int QVBoxLayout_Event(void* ptr, void* e)
{
return static_cast<QVBoxLayout*>(ptr)->event(static_cast<QEvent*>(e));
}
int QVBoxLayout_EventDefault(void* ptr, void* e)
{
return static_cast<QVBoxLayout*>(ptr)->QVBoxLayout::event(static_cast<QEvent*>(e));
}
int QVBoxLayout_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QVBoxLayout*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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();
}
int 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, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQWidget_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWidget_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQWidget_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQWidget_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQWidget_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQWidget_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQWidget_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQWidget_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQWidget_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWidget_MinimumSizeHint(const_cast<MyQWidget*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQWidget_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQWidget_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQWidget_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQWidget_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQWidget_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQWidget_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQWidget_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<MyQWidget*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * event) { callbackQWidget_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQWidget_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQWidget_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_CustomContextMenuRequested(const QPoint & pos) { callbackQWidget_CustomContextMenuRequested(this, this->objectName().toUtf8().data(), new QPoint(static_cast<QPoint>(pos).x(), static_cast<QPoint>(pos).y())); };
bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQWidget_HasHeightForWidth(const_cast<MyQWidget*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQWidget_HeightForWidth(const_cast<MyQWidget*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQWidget_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQWidget_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWidget_InputMethodQuery(const_cast<MyQWidget*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQWidget_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQWidget_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQWidget_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWidget_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQWidget_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQWidget_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQWidget_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWidget_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQWidget_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQWidget_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQWidget_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQWidget_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQWidget_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQWidget_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQWidget_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQWidget_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQWidget_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQWidget_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQWidget_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQWidget_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQWidget_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQWidget_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void Signal_WindowIconChanged(const QIcon & icon) { callbackQWidget_WindowIconChanged(this, this->objectName().toUtf8().data(), new QIcon(icon)); };
void Signal_WindowTitleChanged(const QString & title) { callbackQWidget_WindowTitleChanged(this, this->objectName().toUtf8().data(), title.toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQWidget_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQWidget_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQWidget_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQWidget_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQWidget_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQWidget_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQWidget_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<MyQWidget*>(this), this->objectName().toUtf8().data())); };
};
int QWidget_AcceptDrops(void* ptr)
{
return static_cast<QWidget*>(ptr)->acceptDrops();
}
char* QWidget_AccessibleDescription(void* ptr)
{
return static_cast<QWidget*>(ptr)->accessibleDescription().toUtf8().data();
}
char* QWidget_AccessibleName(void* ptr)
{
return static_cast<QWidget*>(ptr)->accessibleName().toUtf8().data();
}
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();
}
int QWidget_AutoFillBackground(void* ptr)
{
return static_cast<QWidget*>(ptr)->autoFillBackground();
}
void* QWidget_BaseSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWidget*>(ptr)->baseSize()).width(), static_cast<QSize>(static_cast<QWidget*>(ptr)->baseSize()).height());
}
void* QWidget_ChildrenRect(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QWidget*>(ptr)->childrenRect()).x(), static_cast<QRect>(static_cast<QWidget*>(ptr)->childrenRect()).y(), static_cast<QRect>(static_cast<QWidget*>(ptr)->childrenRect()).width(), static_cast<QRect>(static_cast<QWidget*>(ptr)->childrenRect()).height());
}
void* QWidget_ChildrenRegion(void* ptr)
{
return new QRegion(static_cast<QWidget*>(ptr)->childrenRegion());
}
void QWidget_ClearMask(void* ptr)
{
static_cast<QWidget*>(ptr)->clearMask();
}
int 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, int destroyWindow, int 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));
}
int QWidget_FocusPolicy(void* ptr)
{
return static_cast<QWidget*>(ptr)->focusPolicy();
}
void* QWidget_FrameGeometry(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QWidget*>(ptr)->frameGeometry()).x(), static_cast<QRect>(static_cast<QWidget*>(ptr)->frameGeometry()).y(), static_cast<QRect>(static_cast<QWidget*>(ptr)->frameGeometry()).width(), static_cast<QRect>(static_cast<QWidget*>(ptr)->frameGeometry()).height());
}
void* QWidget_FrameSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWidget*>(ptr)->frameSize()).width(), static_cast<QSize>(static_cast<QWidget*>(ptr)->frameSize()).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));
}
int 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));
}
int QWidget_InputMethodHints(void* ptr)
{
return static_cast<QWidget*>(ptr)->inputMethodHints();
}
int QWidget_IsActiveWindow(void* ptr)
{
return static_cast<QWidget*>(ptr)->isActiveWindow();
}
int QWidget_IsFullScreen(void* ptr)
{
return static_cast<QWidget*>(ptr)->isFullScreen();
}
int QWidget_IsMaximized(void* ptr)
{
return static_cast<QWidget*>(ptr)->isMaximized();
}
int QWidget_IsMinimized(void* ptr)
{
return static_cast<QWidget*>(ptr)->isMinimized();
}
int QWidget_IsWindowModified(void* ptr)
{
return static_cast<QWidget*>(ptr)->isWindowModified();
}
void* QWidget_QWidget_KeyboardGrabber()
{
return QWidget::keyboardGrabber();
}
int 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 new QPoint(static_cast<QPoint>(static_cast<QWidget*>(ptr)->mapFromGlobal(*static_cast<QPoint*>(pos))).x(), static_cast<QPoint>(static_cast<QWidget*>(ptr)->mapFromGlobal(*static_cast<QPoint*>(pos))).y());
}
void* QWidget_MapToGlobal(void* ptr, void* pos)
{
return new QPoint(static_cast<QPoint>(static_cast<QWidget*>(ptr)->mapToGlobal(*static_cast<QPoint*>(pos))).x(), static_cast<QPoint>(static_cast<QWidget*>(ptr)->mapToGlobal(*static_cast<QPoint*>(pos))).y());
}
void* QWidget_MaximumSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWidget*>(ptr)->maximumSize()).width(), static_cast<QSize>(static_cast<QWidget*>(ptr)->maximumSize()).height());
}
int QWidget_Metric(void* ptr, int m)
{
return static_cast<QWidget*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(m));
}
void* QWidget_MinimumSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWidget*>(ptr)->minimumSize()).width(), static_cast<QSize>(static_cast<QWidget*>(ptr)->minimumSize()).height());
}
void* QWidget_MinimumSizeHint(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWidget*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QWidget*>(ptr)->minimumSizeHint()).height());
}
void* QWidget_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWidget*>(ptr)->QWidget::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QWidget*>(ptr)->QWidget::minimumSizeHint()).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 new QRect(static_cast<QRect>(static_cast<QWidget*>(ptr)->normalGeometry()).x(), static_cast<QRect>(static_cast<QWidget*>(ptr)->normalGeometry()).y(), static_cast<QRect>(static_cast<QWidget*>(ptr)->normalGeometry()).width(), static_cast<QRect>(static_cast<QWidget*>(ptr)->normalGeometry()).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 new QPalette(static_cast<QWidget*>(ptr)->palette());
}
void* QWidget_Pos(void* ptr)
{
return new QPoint(static_cast<QPoint>(static_cast<QWidget*>(ptr)->pos()).x(), static_cast<QPoint>(static_cast<QWidget*>(ptr)->pos()).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, int 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, int enabled)
{
static_cast<QWidget*>(ptr)->setAutoFillBackground(enabled != 0);
}
void QWidget_SetContextMenuPolicy(void* ptr, int 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, int enable)
{
#ifdef QT_KEYPAD_NAVIGATION
static_cast<QWidget*>(ptr)->setEditFocus(enable != 0);
#endif
}
void QWidget_SetEnabled(void* ptr, int 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, int 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, int 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, int 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, int enable)
{
static_cast<QWidget*>(ptr)->setUpdatesEnabled(enable != 0);
}
void QWidget_SetVisible(void* ptr, int visible)
{
QMetaObject::invokeMethod(static_cast<QWidget*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QWidget_SetVisibleDefault(void* ptr, int 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, int 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, int windowModality)
{
static_cast<QWidget*>(ptr)->setWindowModality(static_cast<Qt::WindowModality>(windowModality));
}
void QWidget_SetWindowModified(void* ptr, int 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(static_cast<double>(level));
}
void QWidget_SetWindowState(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QWidget*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QWidget*>(ptr)->sizeHint()).height());
}
void* QWidget_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWidget*>(ptr)->QWidget::sizeHint()).width(), static_cast<QSize>(static_cast<QWidget*>(ptr)->QWidget::sizeHint()).height());
}
void* QWidget_SizeIncrement(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWidget*>(ptr)->sizeIncrement()).width(), static_cast<QSize>(static_cast<QWidget*>(ptr)->sizeIncrement()).height());
}
char* QWidget_StatusTip(void* ptr)
{
return static_cast<QWidget*>(ptr)->statusTip().toUtf8().data();
}
char* QWidget_StyleSheet(void* ptr)
{
return static_cast<QWidget*>(ptr)->styleSheet().toUtf8().data();
}
char* QWidget_ToolTip(void* ptr)
{
return static_cast<QWidget*>(ptr)->toolTip().toUtf8().data();
}
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 static_cast<QWidget*>(ptr)->whatsThis().toUtf8().data();
}
unsigned long long QWidget_WinId(void* ptr)
{
return static_cast<unsigned long long>(static_cast<QWidget*>(ptr)->winId());
}
char* QWidget_WindowFilePath(void* ptr)
{
return static_cast<QWidget*>(ptr)->windowFilePath().toUtf8().data();
}
void* QWidget_WindowIcon(void* ptr)
{
return new QIcon(static_cast<QWidget*>(ptr)->windowIcon());
}
char* QWidget_WindowIconText(void* ptr)
{
return static_cast<QWidget*>(ptr)->windowIconText().toUtf8().data();
}
int QWidget_WindowModality(void* ptr)
{
return static_cast<QWidget*>(ptr)->windowModality();
}
double QWidget_WindowOpacity(void* ptr)
{
return static_cast<double>(static_cast<QWidget*>(ptr)->windowOpacity());
}
char* QWidget_WindowTitle(void* ptr)
{
return static_cast<QWidget*>(ptr)->windowTitle().toUtf8().data();
}
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, int 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();
}
int 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();
}
int 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 new QMargins(static_cast<QMargins>(static_cast<QWidget*>(ptr)->contentsMargins()).left(), static_cast<QMargins>(static_cast<QWidget*>(ptr)->contentsMargins()).top(), static_cast<QMargins>(static_cast<QWidget*>(ptr)->contentsMargins()).right(), static_cast<QMargins>(static_cast<QWidget*>(ptr)->contentsMargins()).bottom());
}
void* QWidget_ContentsRect(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QWidget*>(ptr)->contentsRect()).x(), static_cast<QRect>(static_cast<QWidget*>(ptr)->contentsRect()).y(), static_cast<QRect>(static_cast<QWidget*>(ptr)->contentsRect()).width(), static_cast<QRect>(static_cast<QWidget*>(ptr)->contentsRect()).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, unsigned long long window, int initializeWindow, int destroyOldWindow)
{
static_cast<QWidget*>(ptr)->create(static_cast<unsigned long long>(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));
}
int QWidget_Event(void* ptr, void* event)
{
return static_cast<QWidget*>(ptr)->event(static_cast<QEvent*>(event));
}
void* QWidget_QWidget_Find(unsigned long long id)
{
return QWidget::find(static_cast<unsigned long long>(id));
}
unsigned long long QWidget_EffectiveWinId(void* ptr)
{
return static_cast<unsigned long long>(static_cast<QWidget*>(ptr)->effectiveWinId());
}
void QWidget_EnsurePolished(void* ptr)
{
static_cast<QWidget*>(ptr)->ensurePolished();
}
int QWidget_FocusNextChild(void* ptr)
{
return static_cast<QWidget*>(ptr)->focusNextChild();
}
int QWidget_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QWidget*>(ptr)->focusNextPrevChild(next != 0);
}
int QWidget_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QWidget*>(ptr)->QWidget::focusNextPrevChild(next != 0);
}
int 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 new 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());
}
int QWidget_ForegroundRole(void* ptr)
{
return static_cast<QWidget*>(ptr)->foregroundRole();
}
void* QWidget_Geometry(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QWidget*>(ptr)->geometry()).x(), static_cast<QRect>(static_cast<QWidget*>(ptr)->geometry()).y(), static_cast<QRect>(static_cast<QWidget*>(ptr)->geometry()).width(), static_cast<QRect>(static_cast<QWidget*>(ptr)->geometry()).height());
}
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, int gesture, int flags)
{
static_cast<QWidget*>(ptr)->grabGesture(static_cast<Qt::GestureType>(gesture), static_cast<Qt::GestureFlag>(flags));
}
int QWidget_GrabShortcut(void* ptr, void* key, int 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();
}
int QWidget_HasEditFocus(void* ptr)
{
#ifdef QT_KEYPAD_NAVIGATION
return static_cast<QWidget*>(ptr)->hasEditFocus();
#else
return false;
#endif
}
int QWidget_HasHeightForWidth(void* ptr)
{
return static_cast<QWidget*>(ptr)->hasHeightForWidth();
}
int QWidget_HasHeightForWidthDefault(void* ptr)
{
return static_cast<QWidget*>(ptr)->QWidget::hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QWidget*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QWidget_InputMethodQueryDefault(void* ptr, int 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));
}
int QWidget_IsAncestorOf(void* ptr, void* child)
{
return static_cast<QWidget*>(ptr)->isAncestorOf(static_cast<QWidget*>(child));
}
int QWidget_IsEnabled(void* ptr)
{
return static_cast<QWidget*>(ptr)->isEnabled();
}
int QWidget_IsEnabledTo(void* ptr, void* ancestor)
{
return static_cast<QWidget*>(ptr)->isEnabledTo(static_cast<QWidget*>(ancestor));
}
int QWidget_IsHidden(void* ptr)
{
return static_cast<QWidget*>(ptr)->isHidden();
}
int QWidget_IsModal(void* ptr)
{
return static_cast<QWidget*>(ptr)->isModal();
}
int QWidget_IsVisible(void* ptr)
{
return static_cast<QWidget*>(ptr)->isVisible();
}
int QWidget_IsVisibleTo(void* ptr, void* ancestor)
{
return static_cast<QWidget*>(ptr)->isVisibleTo(static_cast<QWidget*>(ancestor));
}
int 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 new QPoint(static_cast<QPoint>(static_cast<QWidget*>(ptr)->mapFrom(static_cast<QWidget*>(parent), *static_cast<QPoint*>(pos))).x(), static_cast<QPoint>(static_cast<QWidget*>(ptr)->mapFrom(static_cast<QWidget*>(parent), *static_cast<QPoint*>(pos))).y());
}
void* QWidget_MapFromParent(void* ptr, void* pos)
{
return new QPoint(static_cast<QPoint>(static_cast<QWidget*>(ptr)->mapFromParent(*static_cast<QPoint*>(pos))).x(), static_cast<QPoint>(static_cast<QWidget*>(ptr)->mapFromParent(*static_cast<QPoint*>(pos))).y());
}
void* QWidget_MapTo(void* ptr, void* parent, void* pos)
{
return new QPoint(static_cast<QPoint>(static_cast<QWidget*>(ptr)->mapTo(static_cast<QWidget*>(parent), *static_cast<QPoint*>(pos))).x(), static_cast<QPoint>(static_cast<QWidget*>(ptr)->mapTo(static_cast<QWidget*>(parent), *static_cast<QPoint*>(pos))).y());
}
void* QWidget_MapToParent(void* ptr, void* pos)
{
return new QPoint(static_cast<QPoint>(static_cast<QWidget*>(ptr)->mapToParent(*static_cast<QPoint*>(pos))).x(), static_cast<QPoint>(static_cast<QWidget*>(ptr)->mapToParent(*static_cast<QPoint*>(pos))).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);
}
int QWidget_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QWidget*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QWidget_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QWidget*>(ptr)->QWidget::nativeEvent(QByteArray(eventType), message, &result);
}
void* QWidget_NativeParentWidget(void* ptr)
{
return static_cast<QWidget*>(ptr)->nativeParentWidget();
}
void* QWidget_NextInFocusChain(void* ptr)
{
return static_cast<QWidget*>(ptr)->nextInFocusChain();
}
void QWidget_OverrideWindowFlags(void* ptr, int 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 new QRect(static_cast<QRect>(static_cast<QWidget*>(ptr)->rect()).x(), static_cast<QRect>(static_cast<QWidget*>(ptr)->rect()).y(), static_cast<QRect>(static_cast<QWidget*>(ptr)->rect()).width(), static_cast<QRect>(static_cast<QWidget*>(ptr)->rect()).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, int 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, int 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));
}
int QWidget_RestoreGeometry(void* ptr, char* geometry)
{
return static_cast<QWidget*>(ptr)->restoreGeometry(QByteArray(geometry));
}
char* QWidget_SaveGeometry(void* ptr)
{
return QString(static_cast<QWidget*>(ptr)->saveGeometry()).toUtf8().data();
}
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, int attribute, int on)
{
static_cast<QWidget*>(ptr)->setAttribute(static_cast<Qt::WidgetAttribute>(attribute), on != 0);
}
void QWidget_SetBackgroundRole(void* ptr, int 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, int 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, int 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, int 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, int 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, int 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, int f)
{
static_cast<QWidget*>(ptr)->setParent(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
}
void QWidget_SetShortcutAutoRepeat(void* ptr, int id, int enable)
{
static_cast<QWidget*>(ptr)->setShortcutAutoRepeat(id, enable != 0);
}
void QWidget_SetShortcutEnabled(void* ptr, int id, int 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, int horizontal, int 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 new QSize(static_cast<QSize>(static_cast<QWidget*>(ptr)->size()).width(), static_cast<QSize>(static_cast<QWidget*>(ptr)->size()).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));
}
int QWidget_TestAttribute(void* ptr, int attribute)
{
return static_cast<QWidget*>(ptr)->testAttribute(static_cast<Qt::WidgetAttribute>(attribute));
}
int QWidget_UnderMouse(void* ptr)
{
return static_cast<QWidget*>(ptr)->underMouse();
}
void QWidget_UngrabGesture(void* ptr, int 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");
}
int 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();
}
int 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 static_cast<QWidget*>(ptr)->windowRole().toUtf8().data();
}
int 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));
}
int 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, int 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));
}
int QWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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, this->objectName().toUtf8().data(), parent)); };
void deleteWidget(QWidget * widget) { callbackQWidgetAction_DeleteWidget(this, this->objectName().toUtf8().data(), widget); };
bool event(QEvent * event) { return callbackQWidgetAction_Event(this, this->objectName().toUtf8().data(), event) != 0; };
bool eventFilter(QObject * obj, QEvent * event) { return callbackQWidgetAction_EventFilter(this, this->objectName().toUtf8().data(), obj, event) != 0; };
void setChecked(bool vbo) { callbackQWidgetAction_SetChecked(this, this->objectName().toUtf8().data(), vbo); };
void setEnabled(bool vbo) { callbackQWidgetAction_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setVisible(bool vbo) { callbackQWidgetAction_SetVisible(this, this->objectName().toUtf8().data(), vbo); };
void toggle() { callbackQWidgetAction_Toggle(this, this->objectName().toUtf8().data()); };
void hover() { callbackQWidgetAction_Hover(this, this->objectName().toUtf8().data()); };
void setDisabled(bool b) { callbackQWidgetAction_SetDisabled(this, this->objectName().toUtf8().data(), b); };
void trigger() { callbackQWidgetAction_Trigger(this, this->objectName().toUtf8().data()); };
void timerEvent(QTimerEvent * event) { callbackQWidgetAction_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQWidgetAction_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQWidgetAction_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQWidgetAction_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQWidgetAction_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQWidgetAction_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidgetAction_MetaObject(const_cast<MyQWidgetAction*>(this), this->objectName().toUtf8().data())); };
};
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));
}
int QWidgetAction_Event(void* ptr, void* event)
{
return static_cast<QWidgetAction*>(ptr)->event(static_cast<QEvent*>(event));
}
int QWidgetAction_EventDefault(void* ptr, void* event)
{
return static_cast<QWidgetAction*>(ptr)->QWidgetAction::event(static_cast<QEvent*>(event));
}
int QWidgetAction_EventFilter(void* ptr, void* obj, void* event)
{
return static_cast<QWidgetAction*>(ptr)->eventFilter(static_cast<QObject*>(obj), static_cast<QEvent*>(event));
}
int 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_SetChecked(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QWidgetAction*>(ptr), "setChecked", Q_ARG(bool, vbo != 0));
}
void QWidgetAction_SetCheckedDefault(void* ptr, int vbo)
{
static_cast<QWidgetAction*>(ptr)->QWidgetAction::setChecked(vbo != 0);
}
void QWidgetAction_SetEnabled(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QWidgetAction*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QWidgetAction_SetEnabledDefault(void* ptr, int vbo)
{
static_cast<QWidgetAction*>(ptr)->QWidgetAction::setEnabled(vbo != 0);
}
void QWidgetAction_SetVisible(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QWidgetAction*>(ptr), "setVisible", Q_ARG(bool, vbo != 0));
}
void QWidgetAction_SetVisibleDefault(void* ptr, int 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, int b)
{
QMetaObject::invokeMethod(static_cast<QWidgetAction*>(ptr), "setDisabled", Q_ARG(bool, b != 0));
}
void QWidgetAction_SetDisabledDefault(void* ptr, int 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:
QString _objectName;
QString objectNameAbs() const { return this->_objectName; };
void setObjectNameAbs(const QString &name) { this->_objectName = name; };
MyQWidgetItem(QWidget *widget) : QWidgetItem(widget) {};
QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQWidgetItem_ControlTypes(const_cast<MyQWidgetItem*>(this), this->objectNameAbs().toUtf8().data())); };
Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQWidgetItem_ExpandingDirections(const_cast<MyQWidgetItem*>(this), this->objectNameAbs().toUtf8().data())); };
QRect geometry() const { return *static_cast<QRect*>(callbackQWidgetItem_Geometry(const_cast<MyQWidgetItem*>(this), this->objectNameAbs().toUtf8().data())); };
bool hasHeightForWidth() const { return callbackQWidgetItem_HasHeightForWidth(const_cast<MyQWidgetItem*>(this), this->objectNameAbs().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQWidgetItem_HeightForWidth(const_cast<MyQWidgetItem*>(this), this->objectNameAbs().toUtf8().data(), w); };
bool isEmpty() const { return callbackQWidgetItem_IsEmpty(const_cast<MyQWidgetItem*>(this), this->objectNameAbs().toUtf8().data()) != 0; };
QSize maximumSize() const { return *static_cast<QSize*>(callbackQWidgetItem_MaximumSize(const_cast<MyQWidgetItem*>(this), this->objectNameAbs().toUtf8().data())); };
QSize minimumSize() const { return *static_cast<QSize*>(callbackQWidgetItem_MinimumSize(const_cast<MyQWidgetItem*>(this), this->objectNameAbs().toUtf8().data())); };
void setGeometry(const QRect & rect) { callbackQWidgetItem_SetGeometry(this, this->objectNameAbs().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height())); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidgetItem_SizeHint(const_cast<MyQWidgetItem*>(this), this->objectNameAbs().toUtf8().data())); };
QWidget * widget() { return static_cast<QWidget*>(callbackQWidgetItem_Widget(this, this->objectNameAbs().toUtf8().data())); };
void invalidate() { callbackQWidgetItem_Invalidate(this, this->objectNameAbs().toUtf8().data()); };
QLayout * layout() { return static_cast<QLayout*>(callbackQWidgetItem_Layout(this, this->objectNameAbs().toUtf8().data())); };
int minimumHeightForWidth(int w) const { return callbackQWidgetItem_MinimumHeightForWidth(const_cast<MyQWidgetItem*>(this), this->objectNameAbs().toUtf8().data(), w); };
QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQWidgetItem_SpacerItem(this, this->objectNameAbs().toUtf8().data())); };
};
void* QWidgetItem_NewQWidgetItem(void* widget)
{
return new MyQWidgetItem(static_cast<QWidget*>(widget));
}
int QWidgetItem_ControlTypes(void* ptr)
{
return static_cast<QWidgetItem*>(ptr)->controlTypes();
}
int QWidgetItem_ControlTypesDefault(void* ptr)
{
return static_cast<QWidgetItem*>(ptr)->QWidgetItem::controlTypes();
}
int QWidgetItem_ExpandingDirections(void* ptr)
{
return static_cast<QWidgetItem*>(ptr)->expandingDirections();
}
int QWidgetItem_ExpandingDirectionsDefault(void* ptr)
{
return static_cast<QWidgetItem*>(ptr)->QWidgetItem::expandingDirections();
}
void* QWidgetItem_Geometry(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QWidgetItem*>(ptr)->geometry()).x(), static_cast<QRect>(static_cast<QWidgetItem*>(ptr)->geometry()).y(), static_cast<QRect>(static_cast<QWidgetItem*>(ptr)->geometry()).width(), static_cast<QRect>(static_cast<QWidgetItem*>(ptr)->geometry()).height());
}
void* QWidgetItem_GeometryDefault(void* ptr)
{
return new QRect(static_cast<QRect>(static_cast<QWidgetItem*>(ptr)->QWidgetItem::geometry()).x(), static_cast<QRect>(static_cast<QWidgetItem*>(ptr)->QWidgetItem::geometry()).y(), static_cast<QRect>(static_cast<QWidgetItem*>(ptr)->QWidgetItem::geometry()).width(), static_cast<QRect>(static_cast<QWidgetItem*>(ptr)->QWidgetItem::geometry()).height());
}
int QWidgetItem_HasHeightForWidth(void* ptr)
{
return static_cast<QWidgetItem*>(ptr)->hasHeightForWidth();
}
int 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);
}
int QWidgetItem_IsEmpty(void* ptr)
{
return static_cast<QWidgetItem*>(ptr)->isEmpty();
}
int QWidgetItem_IsEmptyDefault(void* ptr)
{
return static_cast<QWidgetItem*>(ptr)->QWidgetItem::isEmpty();
}
void* QWidgetItem_MaximumSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWidgetItem*>(ptr)->maximumSize()).width(), static_cast<QSize>(static_cast<QWidgetItem*>(ptr)->maximumSize()).height());
}
void* QWidgetItem_MaximumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWidgetItem*>(ptr)->QWidgetItem::maximumSize()).width(), static_cast<QSize>(static_cast<QWidgetItem*>(ptr)->QWidgetItem::maximumSize()).height());
}
void* QWidgetItem_MinimumSize(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWidgetItem*>(ptr)->minimumSize()).width(), static_cast<QSize>(static_cast<QWidgetItem*>(ptr)->minimumSize()).height());
}
void* QWidgetItem_MinimumSizeDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWidgetItem*>(ptr)->QWidgetItem::minimumSize()).width(), static_cast<QSize>(static_cast<QWidgetItem*>(ptr)->QWidgetItem::minimumSize()).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 new QSize(static_cast<QSize>(static_cast<QWidgetItem*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QWidgetItem*>(ptr)->sizeHint()).height());
}
void* QWidgetItem_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWidgetItem*>(ptr)->QWidgetItem::sizeHint()).width(), static_cast<QSize>(static_cast<QWidgetItem*>(ptr)->QWidgetItem::sizeHint()).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();
}
char* QWidgetItem_ObjectNameAbs(void* ptr)
{
if (dynamic_cast<MyQWidgetItem*>(static_cast<QWidgetItem*>(ptr))) {
return static_cast<MyQWidgetItem*>(ptr)->objectNameAbs().toUtf8().data();
}
return QString("QWidgetItem_BASE").toUtf8().data();
}
void QWidgetItem_SetObjectNameAbs(void* ptr, char* name)
{
if (dynamic_cast<MyQWidgetItem*>(static_cast<QWidgetItem*>(ptr))) {
static_cast<MyQWidgetItem*>(ptr)->setObjectNameAbs(QString(name));
}
}
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, this->objectName().toUtf8().data(), id); };
void initializePage(int id) { callbackQWizard_InitializePage(this, this->objectName().toUtf8().data(), id); };
void back() { callbackQWizard_Back(this, this->objectName().toUtf8().data()); };
void Signal_CurrentIdChanged(int id) { callbackQWizard_CurrentIdChanged(this, this->objectName().toUtf8().data(), id); };
void Signal_CustomButtonClicked(int which) { callbackQWizard_CustomButtonClicked(this, this->objectName().toUtf8().data(), which); };
void done(int result) { callbackQWizard_Done(this, this->objectName().toUtf8().data(), result); };
void Signal_HelpRequested() { callbackQWizard_HelpRequested(this, this->objectName().toUtf8().data()); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWizard_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void next() { callbackQWizard_Next(this, this->objectName().toUtf8().data()); };
int nextId() const { return callbackQWizard_NextId(const_cast<MyQWizard*>(this), this->objectName().toUtf8().data()); };
void Signal_PageAdded(int id) { callbackQWizard_PageAdded(this, this->objectName().toUtf8().data(), id); };
void Signal_PageRemoved(int id) { callbackQWizard_PageRemoved(this, this->objectName().toUtf8().data(), id); };
void paintEvent(QPaintEvent * event) { callbackQWizard_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void resizeEvent(QResizeEvent * event) { callbackQWizard_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void restart() { callbackQWizard_Restart(this, this->objectName().toUtf8().data()); };
void setVisible(bool visible) { callbackQWizard_SetVisible(this, this->objectName().toUtf8().data(), visible); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQWizard_SizeHint(const_cast<MyQWizard*>(this), this->objectName().toUtf8().data())); };
bool validateCurrentPage() { return callbackQWizard_ValidateCurrentPage(this, this->objectName().toUtf8().data()) != 0; };
void accept() { callbackQWizard_Accept(this, this->objectName().toUtf8().data()); };
void closeEvent(QCloseEvent * e) { callbackQWizard_CloseEvent(this, this->objectName().toUtf8().data(), e); };
void contextMenuEvent(QContextMenuEvent * e) { callbackQWizard_ContextMenuEvent(this, this->objectName().toUtf8().data(), e); };
int exec() { return callbackQWizard_Exec(this, this->objectName().toUtf8().data()); };
void keyPressEvent(QKeyEvent * e) { callbackQWizard_KeyPressEvent(this, this->objectName().toUtf8().data(), e); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWizard_MinimumSizeHint(const_cast<MyQWizard*>(this), this->objectName().toUtf8().data())); };
void open() { callbackQWizard_Open(this, this->objectName().toUtf8().data()); };
void reject() { callbackQWizard_Reject(this, this->objectName().toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQWizard_ShowEvent(this, this->objectName().toUtf8().data(), event); };
void actionEvent(QActionEvent * event) { callbackQWizard_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQWizard_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWizard_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQWizard_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQWizard_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQWizard_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQWizard_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQWizard_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQWizard_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQWizard_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
void moveEvent(QMoveEvent * event) { callbackQWizard_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQWizard_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQWizard_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setWindowModified(bool vbo) { callbackQWizard_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQWizard_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void changeEvent(QEvent * event) { callbackQWizard_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQWizard_Close(this, this->objectName().toUtf8().data()) != 0; };
bool focusNextPrevChild(bool next) { return callbackQWizard_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQWizard_HasHeightForWidth(const_cast<MyQWizard*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQWizard_HeightForWidth(const_cast<MyQWizard*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQWizard_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQWizard_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWizard_InputMethodQuery(const_cast<MyQWizard*>(this), this->objectName().toUtf8().data(), query)); };
void keyReleaseEvent(QKeyEvent * event) { callbackQWizard_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQWizard_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWizard_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQWizard_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQWizard_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQWizard_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void raise() { callbackQWizard_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQWizard_Repaint(this, this->objectName().toUtf8().data()); };
void setDisabled(bool disable) { callbackQWizard_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQWizard_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQWizard_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQWizard_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQWizard_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQWizard_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQWizard_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQWizard_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQWizard_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQWizard_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQWizard_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQWizard_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQWizard_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQWizard_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQWizard_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQWizard_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQWizard_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQWizard_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWizard_MetaObject(const_cast<MyQWizard*>(this), this->objectName().toUtf8().data())); };
};
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();
}
int 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);
}
int 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, int 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, int format)
{
static_cast<QWizard*>(ptr)->setSubTitleFormat(static_cast<Qt::TextFormat>(format));
}
void QWizard_SetTitleFormat(void* ptr, int format)
{
static_cast<QWizard*>(ptr)->setTitleFormat(static_cast<Qt::TextFormat>(format));
}
void QWizard_SetWizardStyle(void* ptr, int style)
{
static_cast<QWizard*>(ptr)->setWizardStyle(static_cast<QWizard::WizardStyle>(style));
}
int QWizard_StartId(void* ptr)
{
return static_cast<QWizard*>(ptr)->startId();
}
int QWizard_SubTitleFormat(void* ptr)
{
return static_cast<QWizard*>(ptr)->subTitleFormat();
}
int QWizard_TitleFormat(void* ptr)
{
return static_cast<QWizard*>(ptr)->titleFormat();
}
int QWizard_WizardStyle(void* ptr)
{
return static_cast<QWizard*>(ptr)->wizardStyle();
}
void* QWizard_NewQWizard(void* parent, int 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, int which)
{
return static_cast<QWizard*>(ptr)->button(static_cast<QWizard::WizardButton>(which));
}
char* QWizard_ButtonText(void* ptr, int which)
{
return static_cast<QWizard*>(ptr)->buttonText(static_cast<QWizard::WizardButton>(which)).toUtf8().data();
}
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);
}
int 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();
}
int QWizard_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QWizard*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QWizard_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QWizard*>(ptr)->QWizard::nativeEvent(QByteArray(eventType), 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, int 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, int which, void* button)
{
static_cast<QWizard*>(ptr)->setButton(static_cast<QWizard::WizardButton>(which), static_cast<QAbstractButton*>(button));
}
void QWizard_SetButtonText(void* ptr, int 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, int option, int on)
{
static_cast<QWizard*>(ptr)->setOption(static_cast<QWizard::WizardOption>(option), on != 0);
}
void QWizard_SetPixmap(void* ptr, int 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, int visible)
{
static_cast<QWizard*>(ptr)->setVisible(visible != 0);
}
void QWizard_SetVisibleDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QWizard*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QWizard*>(ptr)->sizeHint()).height());
}
void* QWizard_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWizard*>(ptr)->QWizard::sizeHint()).width(), static_cast<QSize>(static_cast<QWizard*>(ptr)->QWizard::sizeHint()).height());
}
int QWizard_TestOption(void* ptr, int option)
{
return static_cast<QWizard*>(ptr)->testOption(static_cast<QWizard::WizardOption>(option));
}
int QWizard_ValidateCurrentPage(void* ptr)
{
return static_cast<QWizard*>(ptr)->validateCurrentPage();
}
int 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 new QSize(static_cast<QSize>(static_cast<QWizard*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QWizard*>(ptr)->minimumSizeHint()).height());
}
void* QWizard_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWizard*>(ptr)->QWizard::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QWizard*>(ptr)->QWizard::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QWizard_SetEnabledDefault(void* ptr, int 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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QWizard_SetWindowModifiedDefault(void* ptr, int 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));
}
int QWizard_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int QWizard_CloseDefault(void* ptr)
{
return static_cast<QWizard*>(ptr)->QWizard::close();
}
int QWizard_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QWizard*>(ptr)->focusNextPrevChild(next != 0);
}
int QWizard_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QWizard*>(ptr)->QWizard::focusNextPrevChild(next != 0);
}
int QWizard_HasHeightForWidth(void* ptr)
{
return static_cast<QWizard*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QWizard*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QWizard_InputMethodQueryDefault(void* ptr, int 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QWizard_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QWizard*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QWizard_SetHiddenDefault(void* ptr, int 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, this->objectName().toUtf8().data()); };
void Signal_CompleteChanged() { callbackQWizardPage_CompleteChanged(this, this->objectName().toUtf8().data()); };
void initializePage() { callbackQWizardPage_InitializePage(this, this->objectName().toUtf8().data()); };
bool isComplete() const { return callbackQWizardPage_IsComplete(const_cast<MyQWizardPage*>(this), this->objectName().toUtf8().data()) != 0; };
int nextId() const { return callbackQWizardPage_NextId(const_cast<MyQWizardPage*>(this), this->objectName().toUtf8().data()); };
bool validatePage() { return callbackQWizardPage_ValidatePage(this, this->objectName().toUtf8().data()) != 0; };
void actionEvent(QActionEvent * event) { callbackQWizardPage_ActionEvent(this, this->objectName().toUtf8().data(), event); };
void dragEnterEvent(QDragEnterEvent * event) { callbackQWizardPage_DragEnterEvent(this, this->objectName().toUtf8().data(), event); };
void dragLeaveEvent(QDragLeaveEvent * event) { callbackQWizardPage_DragLeaveEvent(this, this->objectName().toUtf8().data(), event); };
void dragMoveEvent(QDragMoveEvent * event) { callbackQWizardPage_DragMoveEvent(this, this->objectName().toUtf8().data(), event); };
void dropEvent(QDropEvent * event) { callbackQWizardPage_DropEvent(this, this->objectName().toUtf8().data(), event); };
void enterEvent(QEvent * event) { callbackQWizardPage_EnterEvent(this, this->objectName().toUtf8().data(), event); };
void focusInEvent(QFocusEvent * event) { callbackQWizardPage_FocusInEvent(this, this->objectName().toUtf8().data(), event); };
void focusOutEvent(QFocusEvent * event) { callbackQWizardPage_FocusOutEvent(this, this->objectName().toUtf8().data(), event); };
void hideEvent(QHideEvent * event) { callbackQWizardPage_HideEvent(this, this->objectName().toUtf8().data(), event); };
void leaveEvent(QEvent * event) { callbackQWizardPage_LeaveEvent(this, this->objectName().toUtf8().data(), event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQWizardPage_MinimumSizeHint(const_cast<MyQWizardPage*>(this), this->objectName().toUtf8().data())); };
void moveEvent(QMoveEvent * event) { callbackQWizardPage_MoveEvent(this, this->objectName().toUtf8().data(), event); };
void paintEvent(QPaintEvent * event) { callbackQWizardPage_PaintEvent(this, this->objectName().toUtf8().data(), event); };
void setEnabled(bool vbo) { callbackQWizardPage_SetEnabled(this, this->objectName().toUtf8().data(), vbo); };
void setStyleSheet(const QString & styleSheet) { callbackQWizardPage_SetStyleSheet(this, this->objectName().toUtf8().data(), styleSheet.toUtf8().data()); };
void setVisible(bool visible) { callbackQWizardPage_SetVisible(this, this->objectName().toUtf8().data(), visible); };
void setWindowModified(bool vbo) { callbackQWizardPage_SetWindowModified(this, this->objectName().toUtf8().data(), vbo); };
void setWindowTitle(const QString & vqs) { callbackQWizardPage_SetWindowTitle(this, this->objectName().toUtf8().data(), vqs.toUtf8().data()); };
void showEvent(QShowEvent * event) { callbackQWizardPage_ShowEvent(this, this->objectName().toUtf8().data(), event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQWizardPage_SizeHint(const_cast<MyQWizardPage*>(this), this->objectName().toUtf8().data())); };
void changeEvent(QEvent * event) { callbackQWizardPage_ChangeEvent(this, this->objectName().toUtf8().data(), event); };
bool close() { return callbackQWizardPage_Close(this, this->objectName().toUtf8().data()) != 0; };
void closeEvent(QCloseEvent * event) { callbackQWizardPage_CloseEvent(this, this->objectName().toUtf8().data(), event); };
void contextMenuEvent(QContextMenuEvent * event) { callbackQWizardPage_ContextMenuEvent(this, this->objectName().toUtf8().data(), event); };
bool focusNextPrevChild(bool next) { return callbackQWizardPage_FocusNextPrevChild(this, this->objectName().toUtf8().data(), next) != 0; };
bool hasHeightForWidth() const { return callbackQWizardPage_HasHeightForWidth(const_cast<MyQWizardPage*>(this), this->objectName().toUtf8().data()) != 0; };
int heightForWidth(int w) const { return callbackQWizardPage_HeightForWidth(const_cast<MyQWizardPage*>(this), this->objectName().toUtf8().data(), w); };
void hide() { callbackQWizardPage_Hide(this, this->objectName().toUtf8().data()); };
void inputMethodEvent(QInputMethodEvent * event) { callbackQWizardPage_InputMethodEvent(this, this->objectName().toUtf8().data(), event); };
QVariant inputMethodQuery(Qt::InputMethodQuery query) const { return *static_cast<QVariant*>(callbackQWizardPage_InputMethodQuery(const_cast<MyQWizardPage*>(this), this->objectName().toUtf8().data(), query)); };
void keyPressEvent(QKeyEvent * event) { callbackQWizardPage_KeyPressEvent(this, this->objectName().toUtf8().data(), event); };
void keyReleaseEvent(QKeyEvent * event) { callbackQWizardPage_KeyReleaseEvent(this, this->objectName().toUtf8().data(), event); };
void lower() { callbackQWizardPage_Lower(this, this->objectName().toUtf8().data()); };
void mouseDoubleClickEvent(QMouseEvent * event) { callbackQWizardPage_MouseDoubleClickEvent(this, this->objectName().toUtf8().data(), event); };
void mouseMoveEvent(QMouseEvent * event) { callbackQWizardPage_MouseMoveEvent(this, this->objectName().toUtf8().data(), event); };
void mousePressEvent(QMouseEvent * event) { callbackQWizardPage_MousePressEvent(this, this->objectName().toUtf8().data(), event); };
void mouseReleaseEvent(QMouseEvent * event) { callbackQWizardPage_MouseReleaseEvent(this, this->objectName().toUtf8().data(), event); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWizardPage_NativeEvent(this, this->objectName().toUtf8().data(), QString(eventType).toUtf8().data(), message, *result) != 0; };
void raise() { callbackQWizardPage_Raise(this, this->objectName().toUtf8().data()); };
void repaint() { callbackQWizardPage_Repaint(this, this->objectName().toUtf8().data()); };
void resizeEvent(QResizeEvent * event) { callbackQWizardPage_ResizeEvent(this, this->objectName().toUtf8().data(), event); };
void setDisabled(bool disable) { callbackQWizardPage_SetDisabled(this, this->objectName().toUtf8().data(), disable); };
void setFocus() { callbackQWizardPage_SetFocus2(this, this->objectName().toUtf8().data()); };
void setHidden(bool hidden) { callbackQWizardPage_SetHidden(this, this->objectName().toUtf8().data(), hidden); };
void show() { callbackQWizardPage_Show(this, this->objectName().toUtf8().data()); };
void showFullScreen() { callbackQWizardPage_ShowFullScreen(this, this->objectName().toUtf8().data()); };
void showMaximized() { callbackQWizardPage_ShowMaximized(this, this->objectName().toUtf8().data()); };
void showMinimized() { callbackQWizardPage_ShowMinimized(this, this->objectName().toUtf8().data()); };
void showNormal() { callbackQWizardPage_ShowNormal(this, this->objectName().toUtf8().data()); };
void tabletEvent(QTabletEvent * event) { callbackQWizardPage_TabletEvent(this, this->objectName().toUtf8().data(), event); };
void update() { callbackQWizardPage_Update(this, this->objectName().toUtf8().data()); };
void updateMicroFocus() { callbackQWizardPage_UpdateMicroFocus(this, this->objectName().toUtf8().data()); };
void wheelEvent(QWheelEvent * event) { callbackQWizardPage_WheelEvent(this, this->objectName().toUtf8().data(), event); };
void timerEvent(QTimerEvent * event) { callbackQWizardPage_TimerEvent(this, this->objectName().toUtf8().data(), event); };
void childEvent(QChildEvent * event) { callbackQWizardPage_ChildEvent(this, this->objectName().toUtf8().data(), event); };
void connectNotify(const QMetaMethod & sign) { callbackQWizardPage_ConnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
void customEvent(QEvent * event) { callbackQWizardPage_CustomEvent(this, this->objectName().toUtf8().data(), event); };
void deleteLater() { callbackQWizardPage_DeleteLater(this, this->objectName().toUtf8().data()); };
void disconnectNotify(const QMetaMethod & sign) { callbackQWizardPage_DisconnectNotify(this, this->objectName().toUtf8().data(), new QMetaMethod(sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQWizardPage_EventFilter(this, this->objectName().toUtf8().data(), watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWizardPage_MetaObject(const_cast<MyQWizardPage*>(this), this->objectName().toUtf8().data())); };
};
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 static_cast<QWizardPage*>(ptr)->subTitle().toUtf8().data();
}
char* QWizardPage_Title(void* ptr)
{
return static_cast<QWizardPage*>(ptr)->title().toUtf8().data();
}
void* QWizardPage_NewQWizardPage(void* parent)
{
return new MyQWizardPage(static_cast<QWidget*>(parent));
}
char* QWizardPage_ButtonText(void* ptr, int which)
{
return static_cast<QWizardPage*>(ptr)->buttonText(static_cast<QWizard::WizardButton>(which)).toUtf8().data();
}
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();
}
int QWizardPage_IsCommitPage(void* ptr)
{
return static_cast<QWizardPage*>(ptr)->isCommitPage();
}
int QWizardPage_IsComplete(void* ptr)
{
return static_cast<QWizardPage*>(ptr)->isComplete();
}
int QWizardPage_IsCompleteDefault(void* ptr)
{
return static_cast<QWizardPage*>(ptr)->QWizardPage::isComplete();
}
int 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, int 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, int which, char* text)
{
static_cast<QWizardPage*>(ptr)->setButtonText(static_cast<QWizard::WizardButton>(which), QString(text));
}
void QWizardPage_SetCommitPage(void* ptr, int 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, int finalPage)
{
static_cast<QWizardPage*>(ptr)->setFinalPage(finalPage != 0);
}
void QWizardPage_SetPixmap(void* ptr, int which, void* pixmap)
{
static_cast<QWizardPage*>(ptr)->setPixmap(static_cast<QWizard::WizardPixmap>(which), *static_cast<QPixmap*>(pixmap));
}
int QWizardPage_ValidatePage(void* ptr)
{
return static_cast<QWizardPage*>(ptr)->validatePage();
}
int 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 new QSize(static_cast<QSize>(static_cast<QWizardPage*>(ptr)->minimumSizeHint()).width(), static_cast<QSize>(static_cast<QWizardPage*>(ptr)->minimumSizeHint()).height());
}
void* QWizardPage_MinimumSizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWizardPage*>(ptr)->QWizardPage::minimumSizeHint()).width(), static_cast<QSize>(static_cast<QWizardPage*>(ptr)->QWizardPage::minimumSizeHint()).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, int vbo)
{
QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
}
void QWizardPage_SetEnabledDefault(void* ptr, int 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, int visible)
{
QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
void QWizardPage_SetVisibleDefault(void* ptr, int visible)
{
static_cast<QWizardPage*>(ptr)->QWizardPage::setVisible(visible != 0);
}
void QWizardPage_SetWindowModified(void* ptr, int vbo)
{
QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "setWindowModified", Q_ARG(bool, vbo != 0));
}
void QWizardPage_SetWindowModifiedDefault(void* ptr, int 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 new QSize(static_cast<QSize>(static_cast<QWizardPage*>(ptr)->sizeHint()).width(), static_cast<QSize>(static_cast<QWizardPage*>(ptr)->sizeHint()).height());
}
void* QWizardPage_SizeHintDefault(void* ptr)
{
return new QSize(static_cast<QSize>(static_cast<QWizardPage*>(ptr)->QWizardPage::sizeHint()).width(), static_cast<QSize>(static_cast<QWizardPage*>(ptr)->QWizardPage::sizeHint()).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));
}
int QWizardPage_Close(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
int 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));
}
int QWizardPage_FocusNextPrevChild(void* ptr, int next)
{
return static_cast<QWizardPage*>(ptr)->focusNextPrevChild(next != 0);
}
int QWizardPage_FocusNextPrevChildDefault(void* ptr, int next)
{
return static_cast<QWizardPage*>(ptr)->QWizardPage::focusNextPrevChild(next != 0);
}
int QWizardPage_HasHeightForWidth(void* ptr)
{
return static_cast<QWizardPage*>(ptr)->hasHeightForWidth();
}
int 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, int query)
{
return new QVariant(static_cast<QWizardPage*>(ptr)->inputMethodQuery(static_cast<Qt::InputMethodQuery>(query)));
}
void* QWizardPage_InputMethodQueryDefault(void* ptr, int 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));
}
int QWizardPage_NativeEvent(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QWizardPage*>(ptr)->nativeEvent(QByteArray(eventType), message, &result);
}
int QWizardPage_NativeEventDefault(void* ptr, char* eventType, void* message, long result)
{
return static_cast<QWizardPage*>(ptr)->QWizardPage::nativeEvent(QByteArray(eventType), 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, int disable)
{
QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
}
void QWizardPage_SetDisabledDefault(void* ptr, int 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, int hidden)
{
QMetaObject::invokeMethod(static_cast<QWizardPage*>(ptr), "setHidden", Q_ARG(bool, hidden != 0));
}
void QWizardPage_SetHiddenDefault(void* ptr, int 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));
}
int QWizardPage_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QWizardPage*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
int 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());
}
Reference in a new issue View git blame Copy permalink